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'
  }
Exemple #4
0
  /**
   * 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;
  }
Exemple #6
0
  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
    // }

  }
Exemple #8
0
  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);
  }
Exemple #9
0
  /**
   * 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());
  }
Exemple #12
0
 /** 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;
 }
Exemple #14
0
 @Override
 public void setNodoPadre(Nodo nodo) {
   if (nodo.getClass().equals(Programa.class)) {
     setPrograma((Programa) nodo);
   }
   if (nodo.getClass().equals(Estructura.class)) {
     setEstructuraPadre((Estructura) nodo);
   }
 }
Exemple #15
0
 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) {}
    }
  }
Exemple #20
0
  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 "";
 }
Exemple #22
0
 /**
  * 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();
   }
 }
Exemple #26
0
  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;
  }
Exemple #27
0
 public void push(Nodo nodo) {
   Nodo nuevo = nodo;
   if (tos == null) {
     tos = nodo;
   } else {
     tos.setNext(nodo);
     nodo.setPrevious(tos);
     tos = nodo;
   }
   size++;
 }
Exemple #28
0
 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;
 }