static void Main(string[] args)
{
ArrayList arr = new ArrayList();
nodo n1 = new nodo();
arr.Add("Primero elemento");
arr.Add("Segundo elemento");
arr.Add("Tercero elemento");
n1.Push("Primero elemento");
n1.Push("Segundo elemento");
n1.Push("Tercero elemento");
n1.DesplegarCola();
n1.DesplegarFifo();
n1.Pop();
n1.DesplegarCola();
n1.DesplegarFifo();
n1.Pop();
n1.DesplegarCola();
n1.DesplegarFifo();
n1.Pop();
Console.ReadLine();
//n1.Pop();
Console.ReadLine();
}
}//fin de respuesta
private void animalNuevo(nodo r)
{
String animalnodo = (String)r.valorNodo();
Console.WriteLine("¿Cuál es tu animal pues?");
String nuevoA = Console.ReadLine();
Console.WriteLine($"Qué pregunta con respuesta si/no puedo hacer para poder decir que es un {nuevoA}");
string pregunta = Console.ReadLine();
nodo nodo1 = new nodo(animalnodo);
nodo nodo2 = new nodo(nuevoA);
Console.WriteLine($"para un(a) {nuevoA} la respuesta es si/no?");
r.nuevoValor(pregunta);
if (respuesta())
{
r.izquierda = nodo2;
r.derecha = nodo1;
}
else
{
r.izquierda = nodo1;
r.derecha = nodo2;
}
}
public void jugar()
{
Llena();
nodo Nodo = raiz;
while (Nodo != null)
{//iteración del arbol
a.guardaDatos2(Nodo);
if (Nodo.izquierda != null)
{ //existe una pregunta
Console.WriteLine(Nodo.valorNodo());
Nodo = (respuesta()) ? Nodo.izquierda : Nodo.derecha;
}
else
{
Console.WriteLine($"Ya se, ¿es un {Nodo.valorNodo()}?");
if (respuesta())
{
Console.WriteLine("Gané :)");
}
else
{
animalNuevo(Nodo);
}
Nodo = null;
return;
} //fin if
} //fin while
} //fin jugar
protected void OnEjecutarAction1Activated(object sender, EventArgs e)
{
erroresSintactico = "";
iterator = 0;
if (listaTokens.Count <= 0)
{
return;
}
removeAllColumns(treeview1);
nodo nodo = new nodo(); //Aqui se ejecuta el analizador SINTACTICO
nodo = nodo.programa();
textview6.Buffer.Text = erroresSintactico;
Gtk.TreeViewColumn columna = new Gtk.TreeViewColumn();
columna.Title = "Arbol";
Gtk.CellRendererText celda = new Gtk.CellRendererText();
columna.PackStart(celda, true);
treeview1.AppendColumn(columna);
columna.AddAttribute(celda, "text", 0);
Gtk.TreeStore lista = new Gtk.TreeStore(typeof(string));
verArbol(nodo, lista);
treeview1.ExpandAll(); //Propiedad para expandir el arbol
arbolCompilador = nodo; //Asignamos el arbol del analizador sintactico a nuestra variable estatica
}
public void eliminardato(string eliminante)
{
if (cabeza == null)
{
Console.WriteLine("No hay na\' en la lista para eliminar");
}
else
{
nodo aux = new nodo();
aux.siguiente = cabeza;
nodo recorredor = aux;
while (recorredor.siguiente != null)
{
if (recorredor.siguiente.dato == eliminante)
{
recorredor.siguiente = recorredor.siguiente.siguiente;
}
else
{
recorredor = recorredor.siguiente;
}
}
cabeza = aux.siguiente;
}
}
public string getTypeNode(nodo arbol)
{
string valor = arbol.nombre;
Console.WriteLine("Valor de nodo " + arbol.nombre + ":" + arbol.valor);
switch (arbol.tipoNodo)
{
case TipoNodo.integer:
valor += " (Int: " + arbol.valor.ToString("N0") + ")";
break;
case TipoNodo.float_number:
valor += " (Float: " + arbol.valor.ToString("F") + ")";
break;
case TipoNodo.boolean:
valor += " (Bool: " + (arbol.valor == 1 ? "true" : "false") + ")";
break;
case TipoNodo.undefined:
valor += " (undefined: " + arbol.valor.ToString("F") + ")";
break;
case TipoNodo.error:
valor += " (Error)";
break;
}
return(valor);
}
/* FUNCION BUSQUEDA-POR-PRIMERO-EL-MEJOR()
* 1. Hacer ABIERTOS la cola formada por el nodo inicial (el nodo
* cuyo estado es *ESTADO-INICIAL*, cuyo camino es vacío
* y cuya heurística es la de *ESTADO-INICIAL*);
* Hacer CERRADOS vacío
* 2. Mientras que ABIERTOS no esté vacía,
* 2.1 Hacer ACTUAL el primer nodo de ABIERTOS
* 2.2 Hacer ABIERTOS el resto de ABIERTOS ?
* 2.3 Poner el nodo ACTUAL en CERRADOS.
* 2.4 Si ES-ESTADO-FINAL(ESTADO(ACTUAL)),
* 2.4.1 devolver el nodo ACTUAL y terminar.
* 2.4.2 en caso contrario,
* 2.4.2.1 Hacer NUEVOS-SUCESORES la lista de nodos
* de SUCESORES(ACTUAL) cuyo estado no está
* ni en ABIERTOS ni en CERRADOS
* 2.4.2.2 Hacer ABIERTOS el resultado de incluir
* NUEVOS-SUCESORES en ABIERTOS y ordenar
* en orden creciente de sus heurísticas
* 3. Devolver FALLO.
*/
public nodo DoBestFirst()
{
Queue <nodo> Abiertos = new Queue <nodo>();
Queue <nodo> Cerrados = new Queue <nodo>();
Abiertos.Enqueue(this.estadoInicial);
Cerrados.Clear();
while (Abiertos.Count > 0)
{
nodo Actual = Abiertos.Peek(); //Saca el primer elemento de Abiertos y lo copia a Actual
Cerrados.Enqueue(Abiertos.Dequeue()); //Quita el elemento actual de Abiertos y lo pone en Cerrados
if (Actual.estado != CuboResuelto)
{
foreach (nodo sucesor in Sucesores(Actual))
{
Abiertos.Enqueue(sucesor);
}
Abiertos.OrderBy(x => x.heuristicaVal);
}
else
{
return(Actual);
}
}
return(default(nodo));
}
public void Inserta(T Dato)
{
nodo <T> P = new nodo <T>();
P.dato = Dato;
P.siguiente = A;
A = P;
A2 = A;
}
public static void posorden(nodo r)
{
if (r != null)
{
preorden(r.subarbolIzquierdo());
preorden(r.subarbolDerecho());
r.visitar();
}
}
public void verArbolSemantico(nodo arbol, TreeStore lista, TreeIter iter)
{
if (arbol != null)
{
TreeIter iter1 = lista.AppendValues(iter, getTypeNode(arbol));
arbol.hijos.ForEach(hijo =>
{
verArbolSemantico(hijo, lista, iter1);
});
}
treeview2.Model = lista;
}
public void verArbol(nodo arbol, TreeStore lista, TreeIter iter)
{
if (arbol != null)
{
TreeIter iter1 = lista.AppendValues(iter, arbol.nombre);
arbol.hijos.ForEach(hijo =>
{
verArbol(hijo, lista, iter1);
});
}
treeview1.Model = lista;
}
public static void ObtieneNombreHojas(nodo r)
{
if (r != null)
{
ObtieneNombreHojas(r.subarbolDerecho());
ObtieneNombreHojas(r.subarbolIzquierdo());
string hojasT = r.cuentaHoja();
if (hojasT != null)
{
Console.WriteLine(hojasT + " Es una hoja");
}
}
}
public T Reccorre()
{
T Dato;
if (A != null)
{
Dato = A.dato;
A = A.siguiente;
}
else
{
A = A2;
Dato = default(T);
}
return(Dato);
}
public string buscarNodo([FromUri] string transactionID)
{
string returnresult = "";
Pagina raiz = ArbolB.raiz;
nodo result = arbol.buscarTransaccion(ref raiz, transactionID);
if (result != null)
{
returnresult = "graph { \"TransactionID: " + result.transactionID + ", assetID: " + result.assetID + ", userID: " + result.userID + ", departamento:" + result.departamento + ", empresa: " + result.empresa + ", dias rentados:" + result.diasRentados + "\" }";
}
else
{
returnresult = "graph { \" No se encontró nodo \"}";
}
return(returnresult);
}
public void recorrerABB(nodo r, ref string acum)
{
if (r != null)
{
if (r.izquierda != null)
{
acum += r.dato + "->" + r.izquierda.dato + ";\n";
}
if (r.derecha != null)
{
acum += r.dato + "->" + r.derecha.dato + ";\n";
}
recorrerABB(r.izquierda, ref acum);
recorrerABB(r.derecha, ref acum);
}
}
public void BuildTurretOn(nodo nodo)
{
if (Jugador.gold < turretToBuild.costTorre)
{
print("No tens or suficient");
return;
}
//Eliminem el or del or que tenim
Jugador.gold -= turretToBuild.costTorre;
GameObject tempTorre = (GameObject)Instantiate(turretToBuild.prefabTorre, nodo.GetBuildPosition(), Quaternion.identity);
nodo.torre = tempTorre;
print("Construcció finalitzada, queden" + Jugador.gold);
}
/* FUNCION SUCESORES(NODO)
* 1. Hacer SUCESORES vacío
* 2. Para cada OPERADOR en *OPERADORES*,
* si SUCESOR(NODO,OPERADOR) =/= NO-APLICABLE,
* incluir SUCESOR(NODO,OPERADOR) en SUCESORES
* 3. Devolver SUCESORES
*/
private List <nodo> Sucesores(nodo nodoActual)
{
List <nodo> listaSucesores = new List <nodo>();
foreach (char operador in this.Operadores)
{
nodo aux;
aux = Sucesor(nodoActual, operador);
if (aux.estado != null)
{
listaSucesores.Add(aux);
}
}
return(listaSucesores);
}
public void generarArbol(ref nodo r)
{
string acum = "digraph G{\n";
if (r != null)
{
acum += r.dato + ";\n";
recorrerABB(r, ref acum);
}
acum += "\n}\n";
const string f = "ABB.dot";
StreamWriter w = new StreamWriter(f);
w.WriteLine(acum);
w.Close();
generarImagen("ABB.dot", "ABB.png");
}
public void insercion(string nuevodato)
{
nodo aux = new nodo();
aux.dato = nuevodato;
aux.siguiente = null;
if (cabeza == null)
{
cabeza = aux;
}
else
{
nodo puntero;
puntero = cabeza;
cabeza = aux;
cabeza.siguiente = puntero;
}
}
public nodo LlenaelArbol()
{
StreamReader leer = new StreamReader(direcc);
try
{
string dato = leer.ReadToEnd();
n = JsonConvert.DeserializeObject <nodo>(dato);
}
catch (Exception ex)
{
Console.WriteLine("El error es: " + ex.Message);
}
finally {
leer.Close();
}
return(n);
}
public void guardaDatos2(nodo r)
{
StreamWriter leer = new StreamWriter(direcc);
try
{
string dato = JsonConvert.SerializeObject(r);
leer.WriteLine(dato);
}
catch (Exception ex)
{
Console.WriteLine("Fallo en guardarDatos " + ex.Message);
}
finally
{
leer.Close();
}
}
private nodo localizar(nodo raizSub, comparador buscado)
{
if (raiz == null)
{
return(null);
}
else if (buscado.igualQue(raizSub.valorNodo()))
{
return(raiz);
}
else if (buscado.menorQue(raizSub.valorNodo()))
{
return(localizar(raizSub.subarbolIzquierdo(), buscado));
}
else
{
return(localizar(raizSub.subarbolDerecho(), buscado));
}
}
protected nodo insertar(nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
raizSub = new nodo(dato);
}
else if (dato.menorIgualQue(raizSub.valorNodo()))
{
nodo iz;
iz = insertar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzquierda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
nodo dr;
dr = insertar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDerecha(dr);
}
return(raizSub);
}//end insertar
private nodo Insertar(nodo raizSub, comparador dato)
{
if (raizSub == null)
{
raizSub = new nodo(dato);
}
else if (dato.menorIgualQue(raizSub.valorNodo()))
{
nodo iz;
iz = Insertar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
nodo dr;
dr = Insertar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDcho(dr);
}
return(raizSub);
}
public static int contaHoja(nodo r)
{
int cuenta = 0;
if (r.subarbolDerecho() == null && r.subarbolIzquierdo() == null)
{
cuenta = 1;
}
else
{
if (r.subarbolDerecho() != null)
{
cuenta += contaHoja(r.subarbolDerecho());
}
if (r.subarbolIzquierdo() != null)
{
cuenta += contaHoja(r.subarbolIzquierdo());
}
}
return(cuenta);
}
public static int contaNodo(nodo r)
{
int cuenta = 0;
if (r.valorNodo() == null)
{
cuenta = 0;
}
else
{
cuenta = 1;
if (r.subarbolDerecho() != null)
{
cuenta += contaNodo(r.subarbolDerecho());
}
if (r.subarbolIzquierdo() != null)
{
cuenta += contaNodo(r.subarbolIzquierdo());
}
}
return(cuenta);
}
protected nodo eliminar(nodo raizSub, Comparador dato)
{
if (raizSub == null)
{
throw new Exception("No hay nodo para eliminar");
}
else if (dato.menorQue(raizSub.valorNodo()))
{
nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato);
raizSub.ramaIzquierda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDerecha(dr);
}
else
{
nodo q;
q = raizSub; //este es el nodo que se quita del árbol
if (q.subarbolIzquierdo() == null)
{
raizSub = q.subarbolDerecho();
}
else if (q.subarbolDerecho() == null)
{
raizSub = q.subarbolIzquierdo();
}
else// tiene rama izquierda y derecha
{
q = reemplazar(q);
}
q = null;
}
return(raizSub);
}//end eliminar
private nodo eliminar(nodo raizSub, comparador dato)
{
if (raizSub == null)
{
throw new Exception("No hay nodo para eliminar");
}
else if (dato.menorQue(raizSub.valorNodo()))
{
nodo iz;
iz = eliminar(raizSub.subarbolIzquierdo(), dato);
raiz.ramaIzda(iz);
}
else if (dato.mayorQue(raizSub.valorNodo()))
{
nodo dr;
dr = eliminar(raizSub.subarbolDerecho(), dato);
raizSub.ramaDcho(dr);
}
else //Nodo encontrado
{
nodo q;
q = raizSub;
if (q.subarbolIzquierdo() == null)
{
raizSub = q.subarbolDerecho();
}
else if (q.subarbolDerecho() == null)
{
raizSub = q.subarbolIzquierdo();
}
else //tiene rama ezquierda y derecha
{
q = reemplazar(q);
}
q = null;
}
return(raizSub);
}
private nodo reemplazar(nodo act)
{
nodo a, p;
p = act;
a = act.subarbolIzquierdo(); //rama de nodos menores
while (a.subarbolDerecho() != null)
{
p = a;
p.subarbolDerecho();
}
act.nuevoValor(a.valorNodo());
if (p == act)
{
p.ramaIzda(a.subarbolIzquierdo());
}
else
{
p.ramaDcho(a.subarbolIzquierdo());
}
return(a);
}
protected void OnEjecutarSemantico(object sender, EventArgs e)
{
if (arbolCompilador == null)
{
return;
}
Semantico.fnResetRun(); //Se resetea diccionario y String de errores semanticos
Semantico semantico = new Semantico(arbolCompilador);
semantico.mainSintactico();
removeAllColumns(nodeview1);
buildHashTable();
removeAllColumns(treeview2);
//Dibujamos el arbol semantico
Gtk.TreeViewColumn columna = new Gtk.TreeViewColumn();
columna.Title = "Arbol";
Gtk.CellRendererText celda = new Gtk.CellRendererText();
columna.PackStart(celda, true);
treeview2.AppendColumn(columna);
columna.AddAttribute(celda, "text", 0);
Gtk.TreeStore lista = new Gtk.TreeStore(typeof(string));
verArbolSemantico(semantico.getArbol(), lista);
treeview2.ExpandAll(); //Propiedad para expandir el arbol
arbolCompilador = semantico.getArbol();
}
public char Pop()
{
char valor = ' ';
if (tope == null)
Console.WriteLine("Lista vacia");
else
{
//se elimina el ultimo en entrar y se retorna el valor que se elimina
valor = tope.info;
tope = tope.sgte;
}
return valor;
}
public void Push(char valor)
{
nodo aux = new nodo();
aux.info = valor;
//si no hay nada en la pila
if (tope == null)
{
//se asigna el aux como el unico nodo
tope = aux;
//como solo hay un dato en la pila el puntero se dirige a null
aux.sgte = null;
}
else
{
//si la pila no esta vacia el dato se inserta arriba de la pila
//es decir en el tope
aux.sgte = tope;
tope = aux;
}
}
public pila()
{
tope = null;
}
