/// <summary>
/// GET -> Perfiles / Modulos
/// </summary>
/// <param name="id">ID Perfil</param>
/// <returns>ActionResult</returns>
public ActionResult RolModules(long?id)
{
// -- Si id es nulo se redirige
if (id == null)
{
return(this.BadRequest());
}
// -- Recupero el rol con sus módulos
Rol rol = logic.GetByID(id.Value);
// -- Si no encuentra el perfil se redirige
if (rol.EntityID == 0)
{
return(this.NotFound());
}
ViewBag.tree = Arbol.MakeTree(rol.Modulos.ToList());
return(View(rol));
}
public ActionResult PerfilExterno(string username)
{
String usuario_actual = Session["Usuario"].ToString();
if (username == usuario_actual)
{
return(RedirectToAction("Perfil", "Home"));
}
Arbol arbol = new Arbol();
Usuario usuario = arbol.obtiene_usuario(username);
if (usuario != null)
{
return(View(usuario));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
public ArbolAtaque(bool[] act, Jugador jugador)
{
Nodo uno = new Nodo(1, "CR: 80%", 0);
arbol = new Arbol(uno);
Nodo dos = new Nodo(2, "FF: 30%", 1); //fuerza física
Nodo tres = new Nodo(3, "FMD: 50%", 1); //fuerza mágica
arbol.Raiz.Hijos = new Nodo[] { dos, tres };
Nodo cuatro = new Nodo(4, "habilidad: titan", 2);
arbol.Raiz.Hijos [0].Hijos = new Nodo[] { cuatro };
Nodo cinco = new Nodo(5, "habilidad: volar", 2);
arbol.Raiz.Hijos [1].Hijos = new Nodo[] { cinco };
this.activados = act;
activacionTalentos(jugador);
jugadorEstadisticas = jugador.JugadorEstadisticas;
}
public ActionResult EliminarTuit(String contenido, String tiempo)
{
Arbol arbol = new Arbol();
String username = Session["Usuario"].ToString();
Usuario usuario = arbol.obtiene_usuario(username);
NodoDoblementeEnlazado primero = usuario.tweets_muro.primero;
DateTime fechaTuit = DateTime.ParseExact(tiempo, "d/M/yyyy H:m",
System.Globalization.CultureInfo.InvariantCulture);
Tweet tweet = null;
while (primero != null)
{
tweet = primero.tweet;
if (tweet != null && tweet.usuario.nickname == username && tweet.contenido == contenido && tweet.fechaHora.Year == fechaTuit.Year && tweet.fechaHora.Month == fechaTuit.Month && tweet.fechaHora.Day == fechaTuit.Day && tweet.fechaHora.Hour == fechaTuit.Hour && tweet.fechaHora.Minute == fechaTuit.Minute)
{
break;
}
primero = primero.siguiente;
}
if (tweet != null)
{
usuario.tweets_muro.eliminar(tweet);
arbol.modifica_usuario(usuario);
arbol.inserta_xml_tuits();
for (int i = 0; i < 1027; i++)
{
if (usuario.seguidores.Buscar(i) != null)
{
usuario.seguidores.Buscar(i).tweets_muro.eliminar(tweet);
arbol.modifica_usuario(usuario.seguidores.Buscar(i));
arbol.inserta_xml_tuits();
}
}
Session["Mensaje_Exito"] = "Tweet Eliminado";
}
else
{
Session["Mensaje_Error"] = "Tweet no encontrado";
}
return(RedirectToAction("Index", "Home"));
}
static void Main(string[] args)
{
Arbol <int> arbol = new Arbol <int>(1,
new Arbol <int>(20,
new Arbol <int>(3),
new Arbol <int>(17)
),
new Arbol <int>(5),
new Arbol <int>(6,
new Arbol <int>(7,
new Arbol <int>(22,
new Arbol <int>(21)
)
),
new Arbol <int>(8),
new Arbol <int>(16,
new Arbol <int>(9),
new Arbol <int>(15)
)
),
new Arbol <int>(12)
);
arbol.ImprimeArbol();
Console.WriteLine();
foreach (var el in arbol.Preorden)
{
Console.Write(el);
}
Console.WriteLine();
Resuelve <int>(arbol, arbol, delegate(int ar) { return(ar % 2 == 1); });
arbol.ImprimeArbol();
foreach (var el in arbol.Preorden)
{
Console.Write(el);
}
}
public ActionResult ListadoTuit()
{
Arbol arbol = new Arbol();
String username = Session["Usuario"].ToString();
Usuario usuario = arbol.obtiene_usuario(username);
int tamanio = 0;
NodoDoblementeEnlazado primero = usuario.tweets_muro.primero;
while (primero != null)
{
tamanio++;
primero = primero.siguiente;
}
String[,] listado = new String[tamanio, 5];
NodoDoblementeEnlazado ultimo = usuario.tweets_muro.ultimo;
int contador = 0;
string assemblyFile = (new System.Uri(Assembly.GetExecutingAssembly().CodeBase)).AbsolutePath;
List <Tweet> listado_tweet = new List <Tweet>();
//filling the counts
while (ultimo != null)
{
listado_tweet.Add(ultimo.tweet);
ultimo = ultimo.anterior;
}
listado_tweet = listado_tweet.OrderByDescending(lc => lc.fechaHora).ToList();
ultimo = usuario.tweets_muro.ultimo;
foreach (var tweet in listado_tweet)
{
listado[contador, 0] = tweet.contenido;
listado[contador, 1] = tweet.usuario.nombreCompleto;
listado[contador, 2] = tweet.usuario.ubicacionSinErrorImagen();
listado[contador, 3] = tweet.usuario.nickname;
listado[contador, 4] = tweet.fechaHora.Day + "/" + tweet.fechaHora.Month + "/" + tweet.fechaHora.Year + " " + tweet.fechaHora.Hour + ":" + tweet.fechaHora.Minute;
contador++;
}
string json = JsonConvert.SerializeObject(listado);
return(Content(json, "application/json"));
}
static void Main(string[] args)
{
// prueba1
Arbol <int> myArbol = new Arbol <int>(1,
new Arbol <int>(2,
new Arbol <int>(5,
new Arbol <int>(8),
new Arbol <int>(9,
new Arbol <int>(10,
new Arbol <int>(11),
new Arbol <int>(12,
new Arbol <int>(13)))))),
new Arbol <int>(3,
new Arbol <int>(6),
new Arbol <int>(7)),
new Arbol <int>(4));
bool seEncontro = false;
Resuelve(myArbol, myArbol, ref seEncontro, 10, ref myArbol);
PrintArbol(myArbol, 0);
}
public ActionResult Create([Bind] Module module, long ParentID, int TipoModulo)
{
module.Type = TipoModulo;
if (ModelState.IsValid)
{
// -- Creo el parent solo si eligió alguno
if (ParentID != 0)
{
module.Parent = new Module {
EntityID = ParentID
};
}
module.Activo = true;
logic.Add(module);
TempData["SaveSuccess"] = "Se guardó módulo correctamente";
return(RedirectToAction("Index", "Module"));
}
CargarTipoModulos(module.Type);
ViewBag.tree = Arbol.MakeTree(ParentID);
return(View(module));
}
public static IEnumerable <Arbol> GetArboles(int IdUsuario)
{
List <Arbol> arboles = new List <Arbol>();
using (var con = new SqlConnection(ConfigurationManager.ConnectionStrings[Constantes.KeyConnectionStringComIT].ToString()))
{
con.Open();
var query = new SqlCommand("SELECT * FROM Arbol WHERE IdUsuario = @IdUsuario", con);
query.Parameters.AddWithValue("@IdUsuario", IdUsuario);
using (var dr = query.ExecuteReader())
{
while (dr.Read())
{
Arbol arbol = MapearArbol(dr);
arboles.Add(arbol);
}
}
}
return(arboles);
}
public ActionResult Detalle(int id)
{
ViewBag.Titulo = "Detalle";
Arbol arbol = ArbolManager.GetArbol(id);
String destino = arbol.Latitud + ", " + arbol.Longitud;
JObject arrayDistancias = ArbolManager.CalcularDistancia("-34.9314, -57.9489", destino);
String distancia = arrayDistancias["rows"][0]["elements"][0]["distance"]["text"].ToString();
List <ResultadosViewModel> arboles = new List <ResultadosViewModel>
{
new ResultadosViewModel
{
Id = arbol.Id,
Variedad = arbol.Variedad,
Disponibilidad = arbol.Disponibilidad,
Direccion = arbol.Direccion,
Distancia = distancia
}
};
return(View("Resultados", arboles));
}
public static Arbol <T3> IteraArbol <T3>(Arbol <T3> raiz, int nivel, Filtro <T3> condicion)
{
List <Arbol <T3> > myPreorden = new List <Arbol <T3> >();
HazPreOrden(raiz, myPreorden);
int indiceAnterior = -1;
int maximoAnterior = 0;
for (int indice = 0; indice < myPreorden.Count; indice++)
{
int maximo = 0;
RecorreArbol(myPreorden[indice], 0, nivel, ref maximo, condicion);
if (maximo > maximoAnterior)
{
maximoAnterior = maximo;
indiceAnterior = indice;
}
}
return(myPreorden[indiceAnterior]);
}
public static void Posteriores <T3>(Arbol <T3> arbolActual, IEnumerable <T3> camino, List <T3> posteriores, int llamado)
{
if (llamado <= camino.Count() - 1)
{
bool agrega = false;
foreach (var hijo in arbolActual.Hijos)
{
if (agrega)
{
AgregaDerecha(hijo, posteriores);
}
if (hijo.Valor.Equals(camino.ElementAt(llamado)))
{
agrega = true;
Posteriores(hijo, camino, posteriores, llamado + 1);
}
}
}
}
private void BtnAgregar_Click(object sender, EventArgs e)
{
Arbol nuevoRecurso = new Arbol();
foreach (DataGridViewRow fila in dataGridView1.Rows)
{
nuevoRecurso.Descripcion = "Arbol";
nuevoRecurso.Especie = "Especie Generica";
nuevoRecurso.Latitud = Convert.ToDouble(fila.Cells[1].Value);
nuevoRecurso.Longitud = Convert.ToDouble(fila.Cells[2].Value);
AD_Recursos.AgregarArbol(nuevoRecurso);
}
if (dataGridView1.DataSource is DataTable)
{
((DataTable)dataGridView1.DataSource).Rows.Clear();
dataGridView1.Refresh();
}
//dataGridView1.DataSource = null;
//procedimiento para ingresar en una base de datos
}
public ArbolEquilibrio(bool[] act, Jugador jugador)
{
Nodo uno = new Nodo(1, "VM: +2", 0);
arbol = new Arbol(uno);
Nodo dos = new Nodo(2, "habilidad: curación", 1); //fuerza física
Nodo tres = new Nodo(3, "habilidad: robo de vida", 1); //fuerza mágica
arbol.Raiz.Hijos = new Nodo[] { dos, tres };
Nodo cuatro = new Nodo(4, "habilidad: volar", 2);
arbol.Raiz.Hijos [0].Hijos = new Nodo[] { cuatro };
arbol.Raiz.Hijos [1].Hijos = arbol.Raiz.Hijos [0].Hijos; // apunto al mismo lugar
//arbol.leerPorNivel ();
this.activados = act;
//player = playerController;
activacionTalentos(jugador);
jugadorEstadisticas = jugador.JugadorEstadisticas;
//arbol.leerPorNivel ();
}
public IActionResult Developer(string Titulo, string Descripcion, string Proyecto, string Prioridad, string Fecha)
{
Arbol <Tarea> HeapTarea;
InfoTarea NuevaTarea = new InfoTarea();
Tarea PrioridadT = new Tarea();
//Singleton.Instance.HeapSort;
if (Verificar(Titulo))
{
// Recibe información y la almacena dentro de la tabla hash
NuevaTarea.Titulo = Titulo;
NuevaTarea.Descripcion = Descripcion;
NuevaTarea.Proyecto = Proyecto;
NuevaTarea.FechaEntrega = Fecha;
NuevaTarea.Prioridad = Convert.ToInt32(Prioridad);
Singleton.Instance.Thash.Insertar(NuevaTarea, NuevaTarea.Titulo);
//Se agrega información dentro del heap
PrioridadT.Titulo = Titulo;
PrioridadT.Prioridad = Convert.ToInt32(Prioridad);
Singleton.Instance.THeap.Insertar(PrioridadT);
//.Instance.HeapSort.Vaciar();
HeapTarea = new Arbol <Tarea>();
HeapTarea = Singleton.Instance.THeap;
Singleton.Instance.HeapSort.InsertarFinal(HeapTarea.Eliminar().valor);
return(View(Singleton.Instance.HeapSort));
}
else
{
ViewBag.Mensaje = "Título incorrecto, intente de nuevo";
return(View());
}
}
static void Main(string[] args)
{
Arbol <int> myArbol = new Arbol <int>(20,
new Arbol <int>(4,
new Arbol <int>(10),
new Arbol <int>(15,
new Arbol <int>(-1,
new Arbol <int>(-5),
new Arbol <int>(11),
new Arbol <int>(3,
new Arbol <int>(-9,
new Arbol <int>(14)))))),
new Arbol <int>(30),
new Arbol <int>(-22),
new Arbol <int>(25,
new Arbol <int>(17,
new Arbol <int>(4),
new Arbol <int>(14),
new Arbol <int>(2),
new Arbol <int>(-11)),
new Arbol <int>(-8),
new Arbol <int>(7,
new Arbol <int>(13,
new Arbol <int>(40)),
new Arbol <int>(33))));
Iterador <int> miIterador = new Iterador <int>();
int nivel = 0;
foreach (IEnumerable <int> nodos in miIterador.IteradorAloAncho(myArbol, ValoresPositivos))
{
Console.WriteLine("Nivel {0}", nivel);
foreach (int k in nodos)
{
Console.Write("{0} ", k);
}
Console.WriteLine();
nivel++;
}
}
private void Stock_Click(object sender, RoutedEventArgs e)
{
var arboles = new Arbol
{
Id = Guid.NewGuid(),
Name = FlorisName.Text,
Height = Int32.Parse(TreeSize.Text),
Price = Int32.Parse(TreePrice.Text)
};
DbContext.context.arbol.Add(arboles.Id, arboles);
var flor = new Flor
{
Id = Guid.NewGuid(),
Name = FlorisName.Text,
Color = FlowerColor.Text,
Price = Int32.Parse(FlowerPrice.Text)
};
DbContext.context.flor.Add(flor.Id, flor);
var decoration = new Decorations
{
Id = Guid.NewGuid(),
Name = FlorisName.Text,
Material = Decoration.Text,
Price = Int32.Parse(DecoPrice.Text)
};
DbContext.context.decorations.Add(decoration.Id, decoration);
int TiendasCount = DbContext.context.tiendas.Count;
int suma = 0;
foreach (var i in DbContext.context.arbol.Values)
{
suma = suma + i.Price;
}
NumTiendas.Content = TiendasCount;
TotalEuros.Content = suma;
}
private void crearhijos(string hijotipo, string hijosTareaname)
{
////Recorremos la raiz
for (int iRaiz = 0; iRaiz < raiz.getHijos().Count; iRaiz++)
{
if (raiz.getHijos()[iRaiz].getValor() == hijotipo)
{
//MessageBox.Show("Este tipo ya existe", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
Arbol <String> nomAc = new Arbol <String>(raiz.getHijos()[iRaiz], hijosTareaname); //Se crea hijo segun lo capturado
raiz.getHijos()[iRaiz].agregarHijo(nomAc); //se añade el hijo al padre
noCoicidio = 1;
}
}
if (noCoicidio == 0)
{
//le crea otro el nuevo hijo tipo y su respectiva actividad
Arbol <String> tipos = new Arbol <String>(raiz, hijotipo); //Se Crea el nivel de tipo
Arbol <String> nomAc = new Arbol <String>(tipos, hijosTareaname); //Se crea eñ nivel de actividades
tipos.agregarHijo(nomAc);
raiz.agregarHijo(tipos);
}
}
public ActionResult Nuevo(ArbolViewModel model)
{
if (ModelState.IsValid)
{
Arbol arbol = new Arbol
{
IdUsuario = usuario.Id,
Variedad = model.Variedad,
Disponibilidad = model.Disponibilidad,
Direccion = model.Direccion,
Latitud = model.Latitud,
Longitud = model.Longitud
};
ArbolManager.Nuevo(arbol);
TempData["Msg"] = "Su nuevo árbol fue añadido correctamente";
}
else
{
TempData["Msg"] = "Error al añadir árbol";
}
return(RedirectToAction("Lista", "Arbol"));
}
public static void HazCamino <T1>(Arbol <T1> arbolActual, List <Arbol <T1> > caminoActual, T1 buscado, ref bool encontrado, ref List <Arbol <T1> > camino,
ref List <Arbol <T1> > posteriores)
{
caminoActual.Add(arbolActual);
if (arbolActual.Valor.Equals(buscado))
{
camino = new List <Arbol <T1> >(caminoActual);
encontrado = true;
return;
}
if (encontrado)
{
posteriores.Add(arbolActual);
}
foreach (var hijo in arbolActual.Hijos)
{
HazCamino(hijo, caminoActual, buscado, ref encontrado, ref camino, ref posteriores);
}
caminoActual.RemoveAt(caminoActual.Count - 1);
}
public void Imprime()
{
Arbol ArbolesDeLaBarrranca = new Arbol(); // crea un objeto arbol de BinaryTree
ArbolesDeLaBarrranca.Titular = new Nodo("A");
ArbolesDeLaBarrranca.Titular.Izquierda = new Nodo("B");
ArbolesDeLaBarrranca.Titular.Derecha = new Nodo("E");
ArbolesDeLaBarrranca.Titular.Izquierda.Izquierda = new Nodo("C");
ArbolesDeLaBarrranca.Titular.Izquierda.Derecha = new Nodo("D");
ArbolesDeLaBarrranca.Titular.Derecha.Derecha = new Nodo("F");
ArbolesDeLaBarrranca.Titular.Derecha.Derecha.Izquierda = new Nodo("G");
ArbolesDeLaBarrranca.Titular.Derecha.Derecha.Derecha = new Nodo("H");
Console.WriteLine("Arbol B");
Console.WriteLine("Recorrido preorden del arbol es: ");
ArbolesDeLaBarrranca.PrintPreorder();
Console.WriteLine();
Console.WriteLine("\nRecorrido posorden del arbol es: ");
ArbolesDeLaBarrranca.PrintPostorder();
Console.WriteLine();
Console.ReadKey();
}
public static void Resuelve <T1>(Arbol <T1> arbolActual, Arbol <T1> padre, Condicion <T1> condicion)
{
if (arbolActual.Hijos.Count() > 0)
{
foreach (var hijo in arbolActual.Hijos)
{
Resuelve(hijo, arbolActual, condicion);
}
}
if (arbolActual.Hijos.Count() == 0 && !condicion(arbolActual.Valor))
{
padre.EliminaHijo(arbolActual);
}
else if (arbolActual.Hijos.Count() > 0 && !condicion(arbolActual.Valor))
{
foreach (var hijo in arbolActual.Hijos)
{
padre.InsertaHijo(hijo, arbolActual);
}
padre.EliminaHijo(arbolActual);
}
}
private static void Arbol()
{
string opc = string.Empty;
var arbol = new Arbol();
while (opc != "4")
{
Console.Clear();
Console.WriteLine("1. Ingresar nodo al árbol binario");
Console.WriteLine("2. Consultar ramas de un Nodo");
Console.WriteLine("3. Contar nodos");
Console.WriteLine("4. Salir");
Console.Write("Opción: ");
opc = Console.ReadLine();
switch (opc)
{
case "1":
arbol.InsertarNodo();
break;
case "2":
Console.Write("ingrese el valor del nodo: ");
int n = 0;
int.TryParse(Console.ReadLine(), out n);
arbol.ConsultarRamas(n);
break;
case "3":
arbol.ContarNodos();
break;
default: break;
}
Console.Clear();
}
}
public ActionResult Edit([Bind] Module module, long ParentID, int TipoModulo)
{
module.Type = TipoModulo;
if (ModelState.IsValid)
{
// -- Modifica el modulo
module.Activo = true;
// -- Creo el parent solo si eligió alguno
if (ParentID != 0)
{
module.Parent = new Module {
EntityID = ParentID
};
}
logic.Update(module);
TempData["SaveSuccess"] = "Se guardó módulo correctamente";
return(RedirectToAction("Index", "Module"));
}
// -- Si el modelo no es valido se muestra nuevamente la vista
CargarTipoModulos(module.Type);
ViewBag.tree = Arbol.MakeTree(ParentID);
return(View(module));
}
public static void Resuelve(Arbol arbolActual, string cadena, int myIndice)
{
// ponle un array boleano a esto y terminalo
for (int indice = myIndice; indice < cadena.Length; indice++)
{
Arbol nuevo;
if (cadena[indice] == '(')
{
nuevo = new Arbol(cadena[indice + 1].ToString());
arbolActual.Hijos.Add(nuevo);
Resuelve(nuevo, cadena, indice + 2);
}
else if (char.IsLetter(cadena[indice]))
{
nuevo = new Arbol(cadena[indice].ToString());
continue;
}
else if (cadena[indice] == ')')
{
return;
}
}
}
static void Main(string[] args)
{
Arbol tree = new Arbol();
tree.Raiz.dato = "5";
tree.Raiz.izq = new Nodo(
"3",
new Nodo(
"1",
new Nodo("0")
),
new Nodo("4")
);
tree.Raiz.der = new Nodo(
"7",
new Nodo("6"),
new Nodo(
"9",
new Nodo("8"),
new Nodo("10")
)
);
Console.WriteLine("PRE-ORDEN:");
Arbol.PreOrden(tree.Raiz);
Console.WriteLine("------------------------");
Console.WriteLine("IN-ORDEN:");
Arbol.InOrden(tree.Raiz);
Console.WriteLine("------------------------");
Console.WriteLine("POST-ORDEN:");
Arbol.PostOrden(tree.Raiz);
Console.WriteLine("------------------------");
Console.WriteLine("\nNiveles: {0}", tree.Niveles);
Console.WriteLine("Altura: {0}", tree.Altura);
}
public static Pedido GetPedido(int IdUsuario, int id)
{
Pedido pedido = new Pedido();
using (var con = new SqlConnection(ConfigurationManager.ConnectionStrings[Constantes.KeyConnectionStringComIT].ToString()))
{
con.Open();
var query = new SqlCommand(@"SELECT p.Id, p.Arbol AS ArbolId, a.Variedad AS ArbolVariedad, a.Disponibilidad AS ArbolDisponibilidad, p.Emisor AS EmisorId, us.Nombre AS EmisorNombre, us.NombreUsuario AS EmisorNombreUsuario,
us.Email AS EmisorEmail, u.Id AS ReceptorId, u.Nombre AS ReceptorNombre, u.NombreUsuario AS ReceptorNombreUsuario, u.Email AS ReceptorEmail, pa.IdArbol AS OfertaId, o.Variedad AS OfertaVariedad,
o.Disponibilidad AS OfertaDisponibilidad, p.Estado, p.Visto, p.Fecha
FROM Pedido p INNER JOIN Pedido_Arbol pa ON p.Id = pa.IdPedido
INNER JOIN Arbol a ON p.Arbol = a.Id
INNER JOIN Arbol o ON pa.IdArbol = o.Id
INNER JOIN Usuario us ON p.Emisor = us.Id
INNER JOIN Usuario u ON p.Receptor = u.Id
WHERE p.Id = @Id", con);
query.Parameters.AddWithValue("@IdUsuario", IdUsuario);
query.Parameters.AddWithValue("@Id", id);
List <Arbol> oferta = new List <Arbol>();
using (var dr = query.ExecuteReader())
{
while (dr.Read())
{
pedido = MapearPedido(dr);
if (pedido.Visto == "NoVisto")
{
SetVisto(id);
}
Arbol arbol = MapearOferta(dr);
oferta.Add(arbol);
}
}
pedido.Oferta = oferta;
}
return(pedido);
}
public static int Diferencia <T1>(Arbol <T1> primero, Arbol <T1> segundo)
{
int alturaPrimero = 0;
NivelArbol(primero, ref alturaPrimero, 0);
int alturaSegundo = 0;
NivelArbol(segundo, ref alturaSegundo, 0);
int diferencia = 0;
for (int nivel = 1; nivel <= Math.Max(alturaPrimero, alturaSegundo); nivel++)
{
List <T1> valoresPrimero = new List <T1>();
List <T1> valoresSegundo = new List <T1>();
PreOrdenNivel(primero, valoresPrimero, 0, nivel);
PreOrdenNivel(segundo, valoresSegundo, 0, nivel);
diferencia += Diferencia(valoresPrimero, valoresSegundo);
}
return(diferencia);
}
public ActionResult Busqueda(String valor)
{
if (valor == null || valor == "")
{
return(new EmptyResult());
}
Arbol arbol = new Arbol();
List <dynamic> listado_completo = arbol.listar();
String[,] listado = new String[10, 3];
int contador = 0;
foreach (var item in listado_completo)
{
if ((item.nickname.IndexOf(valor, 0, StringComparison.CurrentCultureIgnoreCase) != -1 || item.nombreCompleto.IndexOf(valor, 0, StringComparison.CurrentCultureIgnoreCase) != -1) && contador < 10 && item.nickname != Session["Usuario"])
{
listado[contador, 0] = item.nickname;
listado[contador, 1] = item.nombreCompleto;
listado[contador, 2] = item.ubicacionSinErrorImagen();
contador++;
}
}
return(View(listado));
}
static void Main(string[] args)
{
Arbol <int> myArbol = new Arbol <int>(4,
new Arbol <int>(3,
new Arbol <int>(9, new Arbol <int> [0]),
new Arbol <int>(7, new Arbol <int> [0])),
new Arbol <int>(6,
new Arbol <int>(5, new Arbol <int> [0])),
new Arbol <int>(20,
new Arbol <int>(10,
new Arbol <int>(13, new Arbol <int> [0]),
new Arbol <int>(2, new Arbol <int> [0]),
new Arbol <int>(1, new Arbol <int> [0])),
new Arbol <int>(10, new Arbol <int> [0])));
Console.WriteLine(myArbol.Max);
Console.WriteLine(Maximo(myArbol));
int max = myArbol.Valor;
Max(myArbol, ref max);
Console.WriteLine(max);
// el minimo es lo mismo cambinado la desigualdad
}
