public void DeberiaAgregarEnlace() { Grafo g = new Grafo(); Nodo n = new Nodo("colo"); Nodo b = new Nodo("pepe"); Enlace e = new Enlace(55, n, b); g.AgregarNodo(n); g.AgregarNodo(b); bool cargo = g.AgregarEnlace(e); Assert.IsTrue(cargo); }
public void DeberiaBorrarEnlace() { Grafo g = new Grafo(); Nodo n = new Nodo("colo"); Nodo b = new Nodo("colo1"); Enlace e = new Enlace(55, n, b); g.AgregarNodo(n); g.AgregarNodo(b); g.AgregarEnlace(e); bool borro = g.BorrarEnlace(e); Assert.IsTrue(borro); }
public void DeberiaAgregarNodo() { Grafo g = new Grafo(); Nodo n = new Nodo("colo"); bool cargo = g.AgregarNodo(n); Assert.IsTrue(cargo); }
private static void Combinar(Nodo[] lista, int inf, int sup, int mitad) { Nodo[] result = new Nodo[lista.Length]; int i = inf, j = mitad + 1, k = inf; while(i <= mitad && j <= sup) { if(lista[i].duración <= lista[j].duración) { result[k] = lista[i]; i++; } else { result[k] = lista[j]; j++; } k++; } while(i <= mitad) { result[k] = lista[i]; i++; k++; } while(j <= sup) { result[k] = lista[j]; j++; k++; } for(k = inf; k <= sup; k++) { lista[k] = result[k]; } }
/// <summary> /// Permite construir un obejeto DataTable. /// </summary> /// <param name="MyNodo">Nodo con key (Nombre columna) y item (Tipo de dato de columna)</param> /// <param name="nomTabla">Nombre de la tabla</param> /// <returns>Objeto datatable construido</returns> /// <remarks> /// <list>Creado: Noviembre 29 de 2013 - Ing. David Pineda</list> /// </remarks> public static DataTable crearTabla(Nodo<string, System.Type>[] MyNodo, string nomTabla = "") { DataTable myDatatable = new DataTable(); DataColumn columna = default(DataColumn); foreach (Nodo<string, System.Type> nodo in MyNodo) { try { columna = new DataColumn(nodo.key); columna.DataType = nodo.item; myDatatable.Columns.Add(columna); } catch (Exception ex) { throw ex; } } if (!string.IsNullOrEmpty(nomTabla)) { myDatatable.TableName = nomTabla; } return myDatatable; }
public Albero(String nome, String tipo, int split, int depth, Dictionary<String, String[]> VertexAttr, Dictionary<String, String[]> EdgeAttr) { this.nome = nome; this.tipo = tipo; this.splitSize = split; this.depth = depth; this.VertexAttributeList = new Dictionary<String, String[]>(); this.EdgeAttributeList = new Dictionary<String, String[]>(); /* * Ho bisogno di una deep copy per salvare le liste di attributi * passate come parametri nell'albero */ foreach (KeyValuePair<String, String[]> attr in VertexAttr) { this.VertexAttributeList.Add(String.Copy(attr.Key), new String[]{String.Copy(attr.Value[0]), String.Copy(attr.Value[1])}); } foreach (KeyValuePair<String, String[]> attr in EdgeAttr) { this.EdgeAttributeList.Add(String.Copy(attr.Key), new String[] { String.Copy(attr.Value[0]), String.Copy(attr.Value[1]) }); } // creazione del nodo radice this.radice = new Nodo(this.nome, this.tipo, currNodeID, this.VertexAttributeList, this.splitSize, null); // creazione dell'albero buildNodes(this.depth, radice); }
public void AgregarNodo(Nodo A) { if (A == null) return; Nodo N = Raiz; while (true) { if (N.inf >= A.inf && N.izq != null) { N = N.izq; continue; } if (N.inf < A.inf && N.der != null) { N = N.der; continue; } break; } if (N.inf < A.inf) { N.der = A; A.pad = N; Balancear(A); return; } if (N.inf >= A.inf) { N.izq = A; A.pad = N; Balancear(A); return; } }
public void Balancear(Nodo Fuente) { while (true) { if (NecesitaBalanceo(Fuente)) { //Balancear!! if (Fuente.pad != null) { Nodo Pad = Fuente.pad; Nodo Bal = BalanceoSimple(Fuente); Bal.pad = Pad; if (Pad.inf < Bal.inf) { Pad.der = Bal; } else { Pad.izq = Bal; } } else { Raiz = BalanceoSimple(Fuente); Raiz.pad = null; } if (Rescate != null) { Rescate.pad = null; AgregarNodo(Rescate); Rescate = null; } } Fuente = Fuente.pad; if (Fuente == null) break; } }
public void Insertar(int x, int y, int d) { Nodo p = null; p = new Nodo(x, y, d); if (inicio == null) inicio = p; else { switch (d) { case 0: p.y = p.y - 10; break; case 1: p.x = p.x + 10; break; case 2: p.y = p.y + 10; break; case 3: p.x = p.x - 10; break; } p.liga = inicio; inicio = p; } }
public void Mov(int d, Nodo p) { if (Perder()) inicio = new Nodo(100, 100, 1); if (p.liga != null) Mov(p.Direccion, p.liga); switch (p.Direccion) { case 0: p.y = p.y - 10; break; case 1: p.x = p.x + 10; break; case 2: p.y = p.y + 10; break; case 3: p.x = p.x - 10; break; } if (p.x < 0) p.x = 190; if (p.x > 190) p.x = 0; if (p.y < 0) p.y = 190; if (p.y > 190) p.y = 0; p.Direccion = d; }
private static void Ordenar(Nodo[] lista, int inf, int sup) { if(inf < sup) { int mitad = (inf + sup) / 2; Ordenar(lista, inf, mitad); Ordenar(lista, mitad + 1, sup); Combinar(lista, inf, sup, mitad); } }
public void DeberiaCrearNodoConNombre() { string nombre = "nodo1"; int x = 55; int y = 33; Nodo n = new Nodo(nombre); Assert.AreEqual(nombre, n.nombre); }
public void DeberiaDevolverNodoNoVisitado() { Nodo NodoA = new Nodo(); Nodo NodoB = new Nodo(); NodoA.visitado = true; Enlace e = new Enlace(33, NodoA, NodoB); var NodoC = e.GetNodoNoVisitado(); Assert.AreEqual(NodoC, NodoB); }
public void DeberiaDevolverTruePorqueLos2NodosFueronVisitados() { Nodo NodoA = new Nodo(); Nodo NodoB = new Nodo(); NodoA.visitado = true; NodoB.visitado = true; Enlace e = new Enlace(33, NodoA, NodoB); Assert.IsTrue(e.NodosVisitados()); }
public void DeberiaModificarNombre() { string nombre = "nodo1"; int x = 55; int y = 33; Nodo n = new Nodo(nombre); n.nombre = "pepe"; Assert.AreEqual(n.nombre, "pepe"); }
public void NoDeberiaAgregarNodosConElMismoNombre() { Grafo g = new Grafo(); Nodo n = new Nodo("colo"); Nodo b = new Nodo("colo"); bool cargo = g.AgregarNodo(n); cargo = g.AgregarNodo(b); Assert.IsFalse(cargo); }
public void DeberiaCrearEnlaceConNodosYPeso() { Nodo NodoA = new Nodo(); Nodo NodoB = new Nodo(); int peso = 33; Enlace e = new Enlace(peso, NodoA, NodoB); Assert.AreEqual(NodoA, e.NodoA); Assert.AreEqual(NodoB, e.NodoB); Assert.AreEqual(peso, e.Peso); }
public void NoDeberiaAgregarEnlaceSiNoExisteElNodo() { Grafo g = new Grafo(); Nodo n = new Nodo("colo"); Nodo b = new Nodo("colo"); Enlace e = new Enlace(55, n, b); bool cargo = g.AgregarEnlace(e); Assert.IsFalse(cargo); }
public void DeberiaModificarPeso() { Nodo NodoA = new Nodo(); Nodo NodoB = new Nodo(); int peso = 33; int peso2 = 23; Enlace e = new Enlace(peso, NodoA, NodoB); e.Peso = peso2; Assert.AreEqual(peso2, e.Peso); }
public void DeberiaModificarNodoB() { Nodo NodoA = new Nodo(); Nodo NodoB = new Nodo(); Nodo NodoC = new Nodo(); int peso = 33; Enlace e = new Enlace(peso, NodoA, NodoB); e.NodoB = NodoC; Assert.AreEqual(NodoC, e.NodoB); }
public Nodo addNodo(Nodo padre, Propuesta prop) { //verifico que el usuario tiene al menos una flor disponible Usuario u = grupo.getUsuario(prop.email); if (nombre == null) throw new appException("Nombre de nodo no puede ser vacio"); else if (u == null) throw new appException("El usuario no existe"); else if (padre == null) throw new appException("El nodo no existe"); else { //agrego nuevo nodo Nodo nuevo = new Nodo(); nuevo.nombre = prop.etiqueta; nuevo.id = lastNodoID++; nuevo.modeloID = prop.modeloID; nuevo.email = prop.email; try { //agrego al arbol if (leftRight) padre.children.Add(nuevo); else padre.children.Insert(0, nuevo); //seguridad if (prop.nivel != getPath(nuevo.id).Count - 1) //quito la raiz throw new Exception("El nivel de la propuesta no coincide con el del arbol"); //fijo nivel nuevo.nivel = prop.nivel; leftRight = !leftRight; //agrego la propuesta prop.nodoID = nuevo.id; //ahora si tiene nodo propuestas.Add(prop); //consumo una flor asignarflor(u, nuevo); } catch (Exception ex) { //no se pudo agregar, quito nodo nuevo padre.children.Remove(nuevo); throw ex; } return nuevo; } }
//***************************************************************** static int CosteEstimado(Nodo X, Datos d) { int coste = X.Creal; int k = X.lugar; if(k != d.dest) { int minFila = int.MaxValue; for(int i = 0; i < d.N; i++) { if(d.T <= d.altura[k, i] && !X.marcado[i]) { minFila = Min(minFila, d.distancia[k, i]); } } coste += minFila; } return coste; }
public void DeberiaRetornarListaCon1NodoSiElGrafoTiene1Nodo() { var g = new Grafo(); var n1 = new Nodo("N1"); var n2 = new Nodo("N2"); g.AgregarNodo(n1); g.AgregarNodo(n2); var e1 = new Enlace(2, n1, n2); g.AgregarEnlace(e1); var l = Kruskal.Ejecutar(g); Assert.IsNotNull(l); Assert.AreEqual(1, l.Count); }
/// <summary> /// Devuelve la Altura del Arbol Binario /// </summary> /// <param name="n">Nodo Raiz</param> /// <returns></returns> public int Altura(Nodo n) { int resultado = 0; if (n != null) { resultado++; int r1 = resultado + Altura(n.izq); int r2 = resultado + Altura(n.der); if (r1 > r2) return r1; else return r2; } return resultado; }
public Trave(Nodo n1, Nodo n2, int numeroTrave, string nomeTrave) : base(numeroTrave, nomeTrave) { nodi = new Nodo[2]; selezionato = false; nodi[0] = n1; nodi[1] = n2; tipo = TipoOggetto.Trave; n1.AggiungiCollegamento(); n2.AggiungiCollegamento(); sezione = new Sezione(); sezione.AggiungiCollegamento(); materiale = new Materiale(); materiale.AggiungiCollegamento(); rifTrave = null; }
public Trave(Nodo n1, Nodo n2) : base() { nodi = new Nodo[NumeroNodi]; selezionato = false; nodi[0] = n1; nodi[1] = n2; tipo = TipoOggetto.Trave; n1.AggiungiCollegamento(); n2.AggiungiCollegamento(); sezione = new Sezione(); sezione.AggiungiCollegamento(); materiale = new Materiale(); materiale.AggiungiCollegamento(); rifTrave = null; }
// procedura ricorsiva per la creazione dei nodi private void buildNodes(int currDepth, Nodo parentNode) { if (currDepth == 0) return; currDepth = currDepth - 1; for (int i = 0; i < parentNode.nodiFigli.Length; i++) { this.currNodeID++; // creazione di ognuno dei nodi figli parentNode.nodiFigli[i] = new Nodo(this.nome, this.tipo, currNodeID, this.VertexAttributeList, this.splitSize, null); // creazione del corretto arco uscente per collegare il nodo appena creato parentNode.archiUscenti[i] = new Arco(parentNode, parentNode.nodiFigli[i], ++this.currEdgeID, this.EdgeAttributeList); // collagamento del nuovo arco nel nodo appena creato parentNode.nodiFigli[i].arcoEntrante = parentNode.archiUscenti[i]; buildNodes(currDepth, parentNode.nodiFigli[i]); } }
public void DeberiaRetornarELEnlaceDeMenorPeso() { var g = new Grafo(); var n1 = new Nodo("N1"); var n2 = new Nodo("N2"); var n3 = new Nodo("N3"); var n4 = new Nodo("N4"); var n5 = new Nodo("N5"); var n6 = new Nodo("N6"); g.AgregarNodo(n1); g.AgregarNodo(n2); g.AgregarNodo(n3); g.AgregarNodo(n4); g.AgregarNodo(n5); g.AgregarNodo(n6); var e1 = new Enlace(2, n1, n2); var e2 = new Enlace(7, n2, n3); var e3 = new Enlace(3, n1, n3); var e4 = new Enlace(20, n1, n6); var e5 = new Enlace(5, n3, n6); var e6 = new Enlace(9, n1, n5); var e7 = new Enlace(3, n5, n4); g.AgregarEnlace(e1); g.AgregarEnlace(e2); g.AgregarEnlace(e3); g.AgregarEnlace(e4); g.AgregarEnlace(e5); g.AgregarEnlace(e6); g.AgregarEnlace(e7); n1.visitado = true; n2.visitado = true; var enlaces = g.GetEnlaces(n1); Enlace eMenor = Prim.EnlaceMenorPeso(enlaces); Assert.IsNotNull(eMenor); Assert.AreNotEqual(eMenor, e1); Assert.AreEqual(eMenor, e3); }
public void DeberiaDevolverLaListaDeEnlacesDe1NodoSiNoSeVisitoElOtroNodo() { Grafo g = new Grafo(); var n1 = new Nodo("N1"); var n2 = new Nodo("N2"); var n3 = new Nodo("N3"); var n4 = new Nodo("N4"); var n5 = new Nodo("N5"); var n6 = new Nodo("N6"); g.AgregarNodo(n1); g.AgregarNodo(n2); g.AgregarNodo(n3); g.AgregarNodo(n4); g.AgregarNodo(n5); g.AgregarNodo(n6); var e1 = new Enlace(2, n1, n2); var e2 = new Enlace(7, n2, n3); var e3 = new Enlace(3, n1, n3); var e4 = new Enlace(20, n1, n6); var e5 = new Enlace(5, n3, n6); var e6 = new Enlace(9, n1, n5); var e7 = new Enlace(3, n5, n4); g.AgregarEnlace(e1); g.AgregarEnlace(e2); g.AgregarEnlace(e3); g.AgregarEnlace(e4); g.AgregarEnlace(e5); g.AgregarEnlace(e6); g.AgregarEnlace(e7); n1.visitado = true; n2.visitado = true; List<Enlace> enlaces = g.GetEnlaces(n1); Assert.IsFalse(enlaces.Contains(e1)); // Esta visitado Assert.IsTrue(enlaces.Contains(e3)); Assert.IsTrue(enlaces.Contains(e4)); Assert.IsTrue(enlaces.Contains(e6)); Assert.IsFalse(enlaces.Contains(e7)); Assert.IsFalse(enlaces.Contains(e2)); Assert.IsFalse(enlaces.Contains(e5)); }
public void DeberiaRetornarARMGrafo() { var g = new Grafo(); var n1 = new Nodo("N1"); var n2 = new Nodo("N2"); var n3 = new Nodo("N3"); var n4 = new Nodo("N4"); var n5 = new Nodo("N5"); var n6 = new Nodo("N6"); g.AgregarNodo(n1); g.AgregarNodo(n2); g.AgregarNodo(n3); g.AgregarNodo(n4); g.AgregarNodo(n5); g.AgregarNodo(n6); var e1 = new Enlace(2, n1, n2); var e2 = new Enlace(7, n2, n3); var e3 = new Enlace(3, n1, n3); var e4 = new Enlace(20, n1, n6); var e5 = new Enlace(5, n3, n6); var e6 = new Enlace(9, n1, n5); var e7 = new Enlace(3, n5, n4); g.AgregarEnlace(e1); g.AgregarEnlace(e2); g.AgregarEnlace(e3); g.AgregarEnlace(e4); g.AgregarEnlace(e5); g.AgregarEnlace(e6); g.AgregarEnlace(e7); var l = Kruskal.Ejecutar(g); Assert.IsNotNull(l); Assert.AreEqual(5, l.Count); Assert.AreEqual(e1, l[0]); Assert.AreEqual(e3, l[1]); Assert.AreEqual(e7, l[2]); Assert.AreEqual(e5, l[3]); Assert.AreEqual(e6, l[4]); }
void ComenzarBusquedaCamino() { //Debug.Log("Comenzando busqueda"); //Se inicialización las listas. listaParcial.Clear(); listaFinal.Clear(); //Se asigna el nodo inicial, es decir el origen del camino. Nodo inicio = new Nodo((int)celdaOrigen.x, (int)celdaOrigen.y); listaParcial.Add(inicio); //Debug.Log("Coordenada de Inicio: " + coordenadaInicio); //Debug.Log("Coordenada de Fin: " + coordenadaFin); //Se revisan los 8 vecinos alrededor del nodo inicial for (int x = (int)celdaOrigen.x - 1; x <= (int)celdaOrigen.x + 1; x++) { for (int y = (int)celdaOrigen.y - 1; y <= (int)celdaOrigen.y + 1; y++) { //Debug.Log("Revisando coordenadas: " +x + " , " +y); //Siempre y cuando no este fuera del tablero... if (x >= 0 && x < ancho && y >= 0 && y < alto) { //Si la celda es suelo, destino o posible camino. if (tablero[x, y] == 0 || tablero[x, y] == 3) { Nodo vecino = new Nodo(x, y, inicio); int funcionG = CalcularFuncionG(vecino); int heuristica = CalcularHeuristica(vecino); vecino.SetFuncionG(funcionG); vecino.SetHeuristica(heuristica); listaParcial.Add(vecino); } } } } listaParcial.Remove(inicio); //Debug.Log("Nodo inicio tiene: " +listaParcial.Count + " vecinos disponibles."); listaFinal.Add(inicio); //Se sigue buscando la solución mientras la lista parcial no este vacía o //no se haya encontrado la solución final. while (listaParcial.Count > 0 && !SeEncontroSolucion()) { int indiceNodoFuncionFMasBaja = ObtenerIndiceNodoConFuncionFMasBaja(); Nodo nodo = listaParcial[indiceNodoFuncionFMasBaja]; //Debug.Log("----------------------------"); //Debug.Log("Posicion Nodo: " + nodo.GetCoordenadas()); //Debug.Log("Funcion F Nodo: " +nodo.GetFuncionF()); listaParcial.Remove(nodo); listaFinal.Add(nodo); //Se revisan los 8 vecinos del nodo actual. for (int x = (int)nodo.GetCoordenadas().x - 1; x <= (int)nodo.GetCoordenadas().x + 1; x++) { for (int y = (int)nodo.GetCoordenadas().y - 1; y <= (int)nodo.GetCoordenadas().y + 1; y++) { //Debug.Log("Revisando coordenadas: " +x + " , " +y); //Si la celda visitada ya esta en la solución final se salta. if (NodoEstaEnListaFinal(x, y)) { //Debug.Log("Ya estaba en la lista final"); continue; } //Mientras no este fuera del tablero... if (x >= 0 && x < ancho && y >= 0 && y < alto) { //Si la celda es suelo, destino o posible camino. if (tablero[x, y] == 0 || tablero[x, y] == 3) { //Si la celda actual no esta en los posibles caminos.. if (!NodoEstaEnListaParcial(x, y)) { //Debug.Log("NO esta en la lista parcial, se agrega como vecino."); Nodo vecino = new Nodo(x, y, nodo); int funcionG = CalcularFuncionG(vecino); int heuristica = CalcularHeuristica(vecino); vecino.SetFuncionG(funcionG); vecino.SetHeuristica(heuristica); listaParcial.Add(vecino); } else { //Debug.Log("SI esta en la lista parcial."); Nodo vecino = NodoEnListaParcial(x, y); Nodo auxiliar = new Nodo(x, y, nodo); int funcionG = CalcularFuncionG(auxiliar); auxiliar.SetFuncionG(funcionG); //Si estaba en la solución parcial entonces se compara //con la función G del camino actual, para ver cual es mejor. if (auxiliar.GetFuncionG() < vecino.GetFuncionG()) { //Debug.Log("El camino actual es mejor que el suyo."); vecino.SetPadre(nodo); int nuevaFuncionG = CalcularFuncionG(vecino); int nuevaHeuristica = CalcularHeuristica(vecino); vecino.SetFuncionG(nuevaFuncionG); vecino.SetHeuristica(nuevaHeuristica); } } } } } } } //Debug.Log("------------------------"); if (SeEncontroSolucion()) { //Debug.Log("Solucion encontrada"); PintarCaminoSolucion(); } else { //Debug.Log("No hay solucion encontrada"); } //Recién en este punto si esta activado la actualización automática, se permite... solucionEncontrada = false; }
public Lista(int valor) { raiz = CrearNodo(valor); }
public Cola() { raiz = null; fondo = null; }
public Pila() { raiz = null; }
static void Main(string[] args) { Red red1 = new Red("Red Patito, S.A. de C.", "Mr Pato Macdonal", "Av. Princeton 123, Orlando Flori"); Nodo nodo1 = new Nodo("192.168.0.10", 0, 5, 10, 0); Nodo nodo2 = new Nodo("192.168.0.12", 1, 2, 12, 1); Nodo nodo3 = new Nodo("192.168.0.20", 2, 8, 5, 2); Nodo nodo4 = new Nodo("192.168.0.15", 0, 10, 22, 0); Vulnerabilidad vul1 = new Vulnerabilidad("CVE-2015-1635", "microsoft", "HTTP.sys permite a atacantes remotos ejecutar código arbitrar", 1, "04/14/2015"); Vulnerabilidad vul2 = new Vulnerabilidad("CVE-2017-0004", "microsoft", "El servicio LSASS permite causar una denegación de servici", 0, "01/10/2010"); nodo1.AgregarVul(vul1); nodo1.AgregarVul(vul2); Vulnerabilidad vul3 = new Vulnerabilidad("CVE-2017-3847", "cisco", "Cisco Firepower Management Center XSS", 1, "02/21/2010"); nodo2.AgregarVul(vul3); Vulnerabilidad vul4 = new Vulnerabilidad("CVE-2009-2504", "microsoft", "Múltiples desbordamientos de enteros en APIs Microsoft .NET 1.1", 0, "11/13/2009"); Vulnerabilidad vul5 = new Vulnerabilidad("CVE-2016-7271", "microsoft", "Elevación de privilegios Kernel Segura en Windows 10 Gol", 0, "12/20/2016"); Vulnerabilidad vul6 = new Vulnerabilidad("CVE-2017-2996", "adove", "Adobe Flash Player 24.0.0.194 corrupción de memoria explotable", 1, "15/02/2017"); nodo3.AgregarVul(vul4); nodo3.AgregarVul(vul5); nodo3.AgregarVul(vul6); red1.AgregarNodo(nodo1); red1.AgregarNodo(nodo2); red1.AgregarNodo(nodo3); red1.AgregarNodo(nodo4); //imprimir datos principales Console.WriteLine("\n >>>Datos generales de la red<<<\n"); Console.WriteLine($"Empresa: {red1.Empresa}"); Console.WriteLine($"Propietario: {red1.Propietario}"); Console.WriteLine($"Domicilio: {red1.Domicilio}"); int suma = 0; foreach (Nodo n in red1.Nodos) { suma += (int)n.totVol(); } Console.WriteLine($"Total Nodos red: {red1.totalNodos()}"); Console.WriteLine($"Total Vulnerabilidades: {suma}\n"); //imprimir datos de nodos gnerales int may = 0; int men = 0; foreach (Nodo n in red1.Nodos) { Console.WriteLine($"IP: {n.Ip}, Tipo: {n.TipoActual}, Puertos: {n.Puertos}, Saltos: {n.Saltos}, So: {n.So}, Totvul: {n.totVol()}"); may = mayor(may, n.Saltos); men = menor(men, n.Saltos); } Console.WriteLine($"\nMayor numero de saltos: {may}"); Console.WriteLine($"Mayor numero de saltos: {men}\n"); Console.WriteLine(" >> Datos generales de los nodos:\n"); foreach (Nodo n in red1.Nodos) { Console.WriteLine($"\nIP: {n.Ip}, Tipo: {n.TipoActual}\n"); if (n.Exploids.Count != 0) { Console.WriteLine("Vulnerabilidades: \n"); foreach (Vulnerabilidad v in n.Exploids) { Console.WriteLine($"Clave: {v.Clave}, Vendedor: {v.Vendedor}, Descripcion: {v.Descripcion}, Tipo: {v.TipoActual}, Fecha: {v.Fecha}"); } } else { Console.WriteLine("No tiene vulnerabilidades .."); } } }
public static void destruirArbol() { raiz = null; }
public void AddVecino(Nodo n, int d) { vecinos.Add(new Arista(n, d)); n.vecinos.Add(new Arista(this, d)); }
public bool find(Nodo nodo, out Nodo encontrado) { return(cerrados.TryGetValue(nodo.vector, out encontrado)); }
protected abstract void Borrar(T Valor, Delegate Delegado, Nodo <T> NodoRaiz);
public bool comprobar(Nodo nodo) { return(cerrados.ContainsKey(nodo.vector)); }
public bool delete(Nodo nodo) { return(cerrados.Remove(nodo.vector)); }
// Metodo encargado de eliminar static void Eliminar() { // Si solo se tiene el primer elemento se comprueba que el dato que se quiere eliminar exista if (Inicio == Final) { if (PaisLocal == Inicio.Pais) { // Se muestra que se ha eliminado el dato Console.WriteLine("\nDato Eliminado: {0} ...", Inicio.Pais); // Al ser el primero y el ultimo lo mismo se declaran como null y se decrementa el tamaño Inicio = Final = null; Tamano--; } // En caso contrario se indica que el dato no existe else { Console.WriteLine("\nEl dato {0} no existe en la lista...", PaisLocal); } } // En caso de que la lista tenga mas de un elemento se comprueba que el dato ingresado no sea el del primer nodo else if (PaisLocal == Inicio.Pais) { // En caso de ser cierto se muestra que se ha eliminado el dato Console.WriteLine("\nDato Eliminado: {0} ...", Inicio.Pais); // Se guarda el nodo inicial en uno temporal Temporal = Inicio; // Ahora inicio será el nodo que le sigue Inicio = Inicio.dir; // Se elimina el nodo temporal Temporal = null; // Se redirecciona el apuntador del final Final.dir = Inicio; // Se decrementa el tamaño Tamano--; } // Se revisa si el dato a eliminar es el ultimo en caso de ser asi se eliminará else if (PaisLocal == Final.Pais) { // Se guarda en una variable temporal el dato a borrar DatoTemp = Final.Pais; // Se establecen nodos auxiliares inicializados en el primer nodo a = Inicio; s = Inicio.dir; // Se recorren los datos de la lista hasta llegar al tope while (s != Final) { a = s; s = s.dir; } // Se establece que el ultimo dato será el anterior al final Final = a; // Se limpia el nodo auxiliar que era el final s = null; // Se redirige el apuntador del final al nodo del inicio Final.dir = Inicio; // Se indica que se ha eliminado el dato Console.WriteLine("\nDato Eliminado: {0} ...", DatoTemp); // Se decrementa el tamaño de la lista Tamano--; } // En caso que no se encuentre el dato a eliminar en los extremos se recorre la lista buscando el dato else { // Se inicializan los nodos auxiliares en el nodo principal a = Inicio; s = Inicio.dir; // Se recorre la lista hasta que se encuentre el dato en la lista while (PaisLocal != s.Pais && s != Final) { a = s; s = s.dir; } // Si el nodo llega al final significa que no coincidió ningun dato if (s == Final) { Console.WriteLine("\nEl dato {0} no existe en la lista...", PaisLocal); } // En caso de no haber llegado al final procedemos eliminar el dato else { // Se muestra el dato eliminado Console.WriteLine("\nDato Eliminado: {0} ...", DatoTemp); // Se restablece el nodo temporal como el siguiente del nodo a eliminar Temporal = s.dir; // En nodo anterior ahora apuntará al nodo temporal a.dir = Temporal; // Se establece s al inicio s = Inicio; } } Console.ReadKey(); }
static void Main(string [] args) { // Mojica Vidal Jonathan Jafet // 19211688 Inicio = null; Final = null; // Declaración del menú bool operando = true; while (operando) { // Se prepara la consola Console.Clear(); Console.Title = "Menu de operaciones con Listas Enlazadas Circulares"; // Despliegue de opciones Console.Write("[1] Insertar\n[2] Eliminar\n[3] Mostrar\n[! Otro] Salir\nSelecciona una opción: "); string opcion = Console.ReadLine(); // Opciones del menu switch (opcion) { case "1": // Se prepara la consola Console.Title = "Insertar elementos en la lista"; // Declaracion del ciclo de captura bool capturando = true; while (capturando) { // Se limpia la consola Console.Clear(); // Captura del pais a registrar Console.Write("Ingresa el pais a registrar: "); PaisLocal = Console.ReadLine(); // Se manda llamar al metodo Insertar(); // Comprobación de la inserción Console.WriteLine(); Imprimir(); // Se comprueba si seguir capturando elementos Console.Write("\n\n[1] Si\n[!] Cualquier otra para no\n¿Deseas capturar otro pais?: "); capturando = Console.ReadLine().Contains("1"); } break; case "2": // Se nombra la consola Console.Title = "Eliminando elementos en la lista"; // Declaración del ciclo de eliminación bool eliminando = true; while (eliminando) { // Se limpia la consola Console.Clear(); // En caso de no estar inicializado el nodo principal significa que la lista está vacia. if (Inicio == null) { Console.Write("Lista Vacia..."); Console.ReadKey(); eliminando = false; } else { // Se limpia la consola Console.Clear(); Imprimir(); // Se solicita que ingrese el dato a eliminar y se almacena en la variable pais local Console.Write("\n¿Que país deseas eliminar?: "); PaisLocal = Console.ReadLine(); // Se llama al método de eliminar Eliminar(); // Se comprueba si quiere seguir eliminando paises if (eliminando) { Console.Write("\n[1] Si\n[!]Cualquier otra para no\n¿Desea seguir eliminando paises?: "); eliminando = Console.ReadLine().Contains("1"); } } } break; case "3": // Se prepara la consola Console.Clear(); Console.Title = "Mostrando la lista"; // Se llama al metodo desplegar Imprimir(); Console.ReadKey(); break; default: operando = false; break; } } }
// Metodo encargado de insertar datos en la lista static void Insertar() { // En caso de no estar inicializada la lista se inicializa los 2 primeros apuntadores // El apuntador final se apunta al inicial if (Inicio == null) { Inicio = new Nodo(); Inicio.Pais = PaisLocal; Final = Inicio; Final.dir = Inicio; } // Se comparan los datos con los apuntadores anteriores para que la lista se encuentre ordenada de manera alfabetica else { // En caso que sea menor significa que el valor a ingresar es anterior al que está en la primer posición if (string.Compare(PaisLocal, Inicio.Pais) < 0) { // Se inicializa un nodo temporal que contendrá el pais ingresado y que apunta al inicio Temporal = new Nodo() { Pais = PaisLocal, dir = Inicio }; // Se establece que el nodo inicial ahora es el Temporal y se redirecciona el apuntador del final. Inicio = Temporal; Final.dir = Inicio; } else if (string.Compare(PaisLocal, Final.Pais) > 0) { // Se inicializa un nodo temporal que contendrá el pais ingresado y apunta al primer nodo Temporal = new Nodo() { Pais = PaisLocal, dir = Inicio }; // Se establece que el nodo Final anterior apuntará al nuevo y el final ahora es el Temporal. Final.dir = Temporal; Final = Temporal; } else { // En caso de no ser mayor a los nodos de las esquinas se ciclará hasta encontrar // uno en el que el dato ingresado sea menor al capturado. // En cada iteracion se recorrerá un nodo a = Inicio; s = Inicio.dir; while (string.Compare(PaisLocal, s.Pais) > 0) { a = s; s = s.dir; } // Se crea un nodo temporal con el dato ingresado y que apuntará al que es mayor que el Temporal = new Nodo() { Pais = PaisLocal, dir = s }; // Al redirecciona el apuntador del nodo anterior a.dir = Temporal; } } // Se aumenta el tamaño Tamano++; }
int CalcularHeuristica(Nodo nodo) { return(10 * ((int)(Mathf.Abs((int)nodo.GetCoordenadas().x - (int)celdaDestino.x)) + (int)(Mathf.Abs((int)nodo.GetCoordenadas().y - (int)celdaDestino.y)))); }
public Arista(Nodo n, int d) { fin = n; distancia = d; }
public Asignacion1(int linea, int columna, Acceso buscador, Nodo exp) : base(linea, columna) { this.asignar = buscador; this.expresion = exp; }
public void Reset() { this.mayorPeso = -1; this.nodoMayorPeso = null; }
public Nodo(T minfo) { info = minfo; this.izq = null; this.der = null; }
public Nodo(char medicamento) { this.medicamento = medicamento; this.Izq = null; this.der = null; }
public static float seach(Nodo raiz) { List <Nodo> stack = new List <Nodo> (); Nodo currentNode = raiz; int j = 0; do { j++; //Debug.Log("1Visitou o " + currentNode.Name); if (float.IsNaN(currentNode.FUtility)) { foreach (Nodo nodo in currentNode.Children) { nodo.Father = currentNode; stack.Add(nodo); } } else { float fUtility = currentNode.FUtility; Nodo father = currentNode.Father; Nodo ancestral; if (father != null) { if (float.IsNaN(father.FUtility)) { father.FUtility = fUtility; //Debug.Log("2Setou o valor para " + fUtility + " o " + father.Name); } else if (father.MaxMin.Equals(Nodo.MaxOrMin.Max)) { if (fUtility > father.FUtility) { father.FUtility = fUtility; //Debug.Log("3Setou o valor para " + fUtility + " o " + father.Name); } } else if (father.MaxMin.Equals(Nodo.MaxOrMin.Min)) { if (fUtility < father.FUtility) { father.FUtility = fUtility; //Debug.Log("4Setou o valor para " + fUtility + " o " + father.Name); } } /*ancestral = father.Father; * * while (ancestral != null) { * * if (father.MaxMin.Equals (Nodo.MaxOrMin.Max)) { * if (ancestral.MaxMin.Equals (Nodo.MaxOrMin.Min) && ancestral.FUtility <= father.FUtility) { * while (stack [stack.Count - 1] != father) { * stack.RemoveAt (stack.Count - 1); * //Debug.Log("5Podou o " + stack[stack.Count - 1].Name); * } * } * } else { * if (ancestral.MaxMin.Equals (Nodo.MaxOrMin.Max) && ancestral.FUtility >= father.FUtility) { * while (stack [stack.Count - 1] != father) { * stack.RemoveAt (stack.Count - 1); * //Debug.Log("6Podou o " + stack[stack.Count - 1].Name); * } * } * } * ancestral = ancestral.Father; * * }*/ } } if (stack.Count > 0) { if (float.IsNaN(stack [stack.Count - 1].FUtility)) { currentNode = stack [stack.Count - 1]; } else { currentNode = stack [stack.Count - 1]; stack.RemoveAt(stack.Count - 1); } } else { currentNode = null; } } while (currentNode != null); //Debug.Log ("Passou : " + j); return(raiz.FUtility); }
public Arbol() { raiz = null; }
public Arbol(Nodo raiz) { this.raiz = raiz; numero_nodos = 0; }
private string Jugar(string cadena, int max, int rondas, bool isParte2) { List <int> inputs = new List <int>(); for (ushort i = 0; i < cadena.Length; i++) { inputs.Add(int.Parse(cadena[i].ToString())); } int valorMaximo = inputs.Max(); if (max > 0) { for (int j = valorMaximo + 1; j <= max; j++) { inputs.Add(j); } } int indice = max + 1; if (max == 0) { indice = 10; } Nodo[] nodos = new Nodo[indice]; Nodo nodoStart = new Nodo(inputs[0]); nodos[inputs[0]] = nodoStart; Nodo nodoAnterior = nodoStart; for (int i = 1; i < inputs.Count; i++) { Nodo nodoActual = new Nodo(inputs[i]); nodos[inputs[i]] = nodoActual; nodoAnterior.Next = nodoActual; nodoAnterior = nodoActual; if (inputs[i] > valorMaximo) { valorMaximo = inputs[i]; } } nodoAnterior.Next = nodoStart; Nodo nodoCurrent = nodoStart; for (int j = 0; j < rondas; j++) { Nodo nodoSiguiente = nodoCurrent.Next; nodoCurrent.Next = nodoSiguiente.Next.Next.Next; int destVal = FindPositionDestination(nodoCurrent.value, nodoSiguiente, valorMaximo); Nodo ip = nodos[destVal]; Nodo ipn = ip.Next; Nodo tail = nodoSiguiente.Next.Next; tail.Next = ipn; ip.Next = nodoSiguiente; nodoCurrent = nodoCurrent.Next; } string resultado = ""; if (isParte2 == false) { resultado = nodosToString(nodoStart, 1); } else { Nodo nodoActual = nodos[1]; ulong res = (ulong)nodoActual.Next.value * (ulong)nodoActual.Next.Next.value; resultado = res.ToString(); } return(resultado); }
//Insertar------------------------------------- public void InsertarInicio(Nodo t) { PrimerNodo = t; }
static ArbolEscala() { raiz = null; }
public void insertarfinal(Nodo t) { UltimoNodo = t; }
public ArbolBinarioOrdenado() { raiz = null; }
protected abstract void Insertar(T Valor, Delegate Delegado, Nodo <T> NodoRaiz);
public ABB() { raiz = null; }