private int abortarCaminho() { System.out.println("Abortando caminho"); // Não existe mais caminhos alternativos if (_BT.isEmpty()) { return NAO_ENCONTROU_CAMINHO; } _FS = _FS._Pai; // Voltar a derivação ao nodo Pai _FS.eliminarCaminho( _BT .lastElement()); // Eliminar caminho atual. Aponta o _BT.lastElement() para o próximo // caminho. /** Caso exista um próximo caminho através do nodo Pai */ if (_BT.lastElement() < _FS.getMaxBacktracking()) { _FS = _FS.getCaminho(_BT.lastElement()); // Pesquisar novo caminho return PROXIMO_PASSO; /** Caso não exista um próximo caminho através do nodo Pai */ } else { _BT.remove(_BT.size() - 1); // Eliminar Backtracking do Pai return ABORTAR_CAMINHO; // Pesquisar caminhos alternativos pelo Avô } }
public void mostrar() { Nodo<T> aux = inicio; while (aux != null) { System.out.println(aux.getInfo()); aux = aux.getLiga(); } }
// ------------------------------------------ public void Borra_Posicion(int pos) // Las posiciones empiezan desde 1. { Nodo aux, ant; int cont = 1; aux = primero; ant = null; while (aux != null) { if (pos == cont) { if (ant == null) // Primero { primero = primero.sig; aux = null; // Para que borre efectivamente el nodo. } else { ant.sig = aux.sig; aux = null; // Para que borre efectivamente el nodo. } } else { ant = aux; aux = aux.sig; cont++; } // Fin del 'else } // Fin del 'while' }
/** * Function to print the tree. * * @param depth Depth of the node in the tree. * @param text The tree. */ private void printTree(int depth, StringBuffer text) { String aux = ""; String aux2 = ""; for (int k = 0; k < depth - 1; k++) { aux += "\t"; } for (int k = 0; k < depth; k++) { aux2 += "\t"; } text.append(aux2); if (nodo.isLeaf) { // text.append(nodo.printString() + " ["+indiceNodoT+"]\n"); text.append(nodo.printString() + " \n"); } else if (nodo != null) { /*text.append("[" + indiceNodo + "/" + marcado + "] if ( " + nodo.printString() + " ) then{\n");*/ if (hijoI != null) { text.append("if ( " + nodo.printString() + " ) then{\n"); hijoI.printTree(depth + 1, text); } if (hijoD != null) { text.append(aux2 + "else{ \n"); hijoD.printTree(depth + 1, text); } } text.append(aux + "}\n"); }
protected ArrayList<Nodo> actualizarAbiertos( ArrayList<Nodo> lAbiertos, ArrayList<Nodo> lCerrados, ArrayList<Nodo> lvecinos, Nodo nFinal) { Nodo nVecino = null; // ArrayList<Nodo> auxLAbiertos=lAbiertos; boolean estaEnAbiertos = false; boolean estaEnCerrados = false; for (int i = 0; i < lvecinos.size(); i++) { estaEnAbiertos = false; estaEnCerrados = false; nVecino = lvecinos.get(i); for (int k = 0; k < lCerrados.size(); k++) { if (nVecino.comparaEsNodo(lCerrados.get(k))) { estaEnCerrados = true; } } if (!estaEnCerrados) { for (int j = 0; j < lAbiertos.size(); j++) { if (nVecino.comparaEsNodo(lAbiertos.get(j))) { estaEnAbiertos = true; if (nVecino.getCosteF() < lAbiertos.get(j).getCosteF()) { lAbiertos.remove(j); lAbiertos.add(nVecino); } } } if (!estaEnAbiertos) lAbiertos.add(nVecino); } } return lAbiertos; }
public boolean eliminar(String cadena) { boolean borrado = false; Nodo mNodo; Nodo antNodo; // Buscando el nodo con el número mNodo = this.Inicio; while ((mNodo != null) && (!mNodo.getDato().equals(cadena))) { mNodo = mNodo.getSiguiente(); } if (mNodo != null) { if (mNodo == this.Inicio) { this.Inicio = this.Inicio.getSiguiente(); } else if (mNodo == this.Fin) { // Llegar al anterior al fin antNodo = this.Inicio; while (antNodo.getSiguiente() != mNodo) { antNodo = antNodo.getSiguiente(); } this.Fin = antNodo; this.Fin.setSiguiente(null); } else { // Llengar al anterior al buscado antNodo = this.Inicio; while (antNodo.getSiguiente() != mNodo) { antNodo = antNodo.getSiguiente(); } antNodo.setSiguiente(mNodo.getSiguiente()); } borrado = true; } return borrado; }
protected ArrayList<Nodo> calcularVecinos(ArrayList<Nodo> lvecinos, Nodo nActual) { int x = nActual.getPosX(); int z = nActual.getPosZ(); if (m_Map.CanWalk(x + 1, z)) { lvecinos.add(new Nodo(x + 1, z, nActual)); } if (m_Map.CanWalk(x - 1, z)) { lvecinos.add(new Nodo(x - 1, z, nActual)); } if (m_Map.CanWalk(x, z + 1)) { lvecinos.add(new Nodo(x, z + 1, nActual)); } if (m_Map.CanWalk(x, z - 1)) { lvecinos.add(new Nodo(x, z - 1, nActual)); } return lvecinos; // consideramos que el coste es 1 siempre // El métdo getCost de m_Map es también para coger el coste, porque no es lo mismo si está por // agua que por tierra // pero en este caso no importa, cogemos 1 // } }
private void elimina(Nodo<T> t, T elemento) { if (t == null) return; if (t.elemento.equals(elemento)) { if (cabeza == rabo && t == cabeza) { cabeza = null; rabo = cabeza; } else if (t == cabeza) { cabeza = cabeza.siguiente; cabeza.anterior = null; } else if (t == rabo) { rabo = rabo.anterior; rabo.siguiente = null; } else { t.anterior.siguiente = t.siguiente; t.siguiente.anterior = t.anterior; } longitud -= 1; } elimina(t.siguiente, elemento); }
/** * Función que obtiene el otro extremo de Canal. * * @param a * @return */ public Nodo getOtroExtremo(Nodo a) { if (!a.equals(extremoA) && !a.equals(extremoB)) return null; if (a.equals(extremoA)) return extremoB; return extremoA; }
@Test public void test_Nodo_GetSiguiente2() { Nodo nodo1 = new Nodo(); Nodo nodo2 = new Nodo(7); nodo1.SetSiguiente(nodo2); assertEquals(7, nodo1.GetSiguiente().GetInformacion()); }
@Test public void test_Nodo_GetSiguiente() { Nodo nodo1 = new Nodo(); Nodo nodo2 = new Nodo(); nodo1.SetSiguiente(nodo2); assertNotSame(null, nodo1.GetSiguiente()); }
/** arruma a profundidade de um nodo e de seus pais */ void setProfundidade() { if (pai == null) { profundidade = 0; } else { pai.setProfundidade(); profundidade = pai.getProfundidade() + 1; } }
public int tamano() { int resultado = 0; Nodo<T> actual = raiz; while (actual != null) { actual = actual.getSiguiente(); resultado++; } return resultado; }
@Override public void setNodoPadre(Nodo nodo) { if (nodo.getClass().equals(Programa.class)) { setPrograma((Programa) nodo); } if (nodo.getClass().equals(Estructura.class)) { setEstructuraPadre((Estructura) nodo); } }
private boolean existeNodoIgual(String nomeNodo) { for (int i = 0; i < this.nodos.size(); i++) { Nodo temp = this.nodos.get(i); if (temp.getNome().equals(nomeNodo)) { return true; } } return false; }
// --------------------------------------------- public void Quitar_Ultimo() { Nodo aux = primero; if (aux.sig == null) Lista_Vacia(); if (!Esta_Vacia()) { aux = primero; while (aux.sig.sig != null) aux = aux.sig; aux.sig = null; } }
public ListaLigada<T> invertirLista() { ListaLigada<T> respuesta = new ListaLigada<>(); Nodo<T> aux = inicio; while (aux != null) { respuesta.insertarInicio(aux.getInfo()); aux = aux.getLiga(); } return respuesta; }
public void borrarFinal() { Nodo<T> aux = inicio; Nodo<T> anterior = null; while (aux.getLiga() != null) { anterior = aux; aux = aux.getLiga(); } anterior.setLiga(null); }
public void ordenar(char direccion) { T aux = null; Nodo<T> nodoActual = inicio; Nodo<T> aux2 = null; while (nodoActual.getLiga() != null) { aux2 = nodoActual.getLiga(); while (aux != null) {} } }
public int contar() { Nodo mNodo = Inicio; int contador = 0; while (mNodo != null) { mNodo = mNodo.getSiguiente(); contador++; } return contador; }
public String toString() { // Se despliega el valor del nodo acutal. Nodo first = _first; if (_first != null) { while (first.getNext() != null) { System.out.println("El valor del Nodo es: " + first.getValue()); first = first.getNext(); } } return ""; }
/** * verifica se o valor a ser inserido é maior ao valor do nodo atual. Caso seja passa o processo * de inserção para o nodo adiante. SE o valor do nodo atual for maior que o valor a ser inserido, * então o nodo atual comanda a inserção entre o nodo anterior e o nodo atual. (else) para isso os * seguintes passos são seguidos: o 'anterio' do novo nodo a ser inserido é apontado para o * anterior do nodo atual o 'proximo' do novo nodo a ser inserido é apontado para o nodo atual o * 'proximo' do nodo anterior é apontado para o nodo a ser inserido o 'anterior' do nodo atual é * apontado para o nodo a ser inserido * * @param novo */ public void inserir(Nodo<T> novo) { if (novo.valor.compareTo(this.valor) >= 0) { proximo.inserir(novo); } else { novo.anterior = this.anterior; novo.proximo = this; this.anterior.proximo = novo; this.anterior = novo; } }
// --------------------------------------------- public void Insertar_Primero(Carta p) { Nodo nuevo = new Nodo(p); // Caso a) --> Lista vacÃa if (primero == null) primero = nuevo; else { nuevo.sig = primero; primero = nuevo; } }
public void insertar(T obj) { if (raiz == null) { raiz = new Nodo<T>(obj); return; } Nodo<T> nuevo = new Nodo<T>(obj); nuevo.setSiguiente(raiz); raiz = nuevo; }
public void quitarDuplicados() { Nodo<T> aux = inicio; Nodo<T> aux2 = null; T dato = null; while (aux.getLiga() != null) { dato = aux.getInfo(); aux2 = inicio; int indice = 0; boolean duplicado = false; while (aux2 != null) { if (dato.equals(aux2.getInfo())) { if (!duplicado) { duplicado = true; aux2 = aux2.getLiga(); indice++; } else { aux2 = aux2.getLiga(); borrar(indice); indice++; } } else { indice++; aux2 = aux2.getLiga(); } } aux = aux.getLiga(); } }
public void agregar(String cadena) { Nodo mNodo = new Nodo(); mNodo.setDato(cadena); if (this.Inicio == null) { this.Inicio = mNodo; } else { this.Fin.setSiguiente(mNodo); } this.Fin = mNodo; }
public void push(Nodo nodo) { Nodo nuevo = nodo; if (tos == null) { tos = nodo; } else { tos.setNext(nodo); nodo.setPrevious(tos); tos = nodo; } size++; }
public void removeRoutesOf(Nodo p1) { for (int i = 0; i < routes.size(); i++) { if (p1.getName().equals(routes.get(i).getNodo1().getName()) || p1.getName().equals(routes.get(i).getNodo2().getName())) { routes.remove(i); System.out.println("YES"); } else { System.out.println("NO"); } } }
/** * Agrega un elemento al tope de la pila. * * @param elemento el elemento a agregar. */ @Override public void mete(T elemento) { if (elemento == null) throw new IllegalArgumentException(); Nodo nodo = new Nodo(elemento); if (cabeza == null) cabeza = rabo = nodo; else { nodo.siguiente = cabeza; cabeza = nodo; } }
public boolean buscar(T dato) { boolean resultado = false; Nodo<T> aux = inicio; while (aux != null) { if (aux.getInfo().equals(dato)) { resultado = true; } aux = aux.getLiga(); } return resultado; }