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;
}
