> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/exercicios-java/ud6-solucions/listas.md).

# Listas

1. Inclue as seguintes cidades:

   Engadimos 
2. Código de Lista

```java
package Listas;

public class Nodo<E> {
    private E elemento;
    private Nodo<E> siguiente;

    public Nodo(E elemento) {
        this.elemento = elemento;
        this.siguiente = null;
    }

    public E getElemento() {
        return elemento;
    }

    public void setElemento(E elemento) {
        this.elemento = elemento;
    }

    public Nodo getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo siguiente) {
        this.siguiente = siguiente;
    }

    @Override
    public String toString() {
        return "Nodo{" +
                "elemento=" + elemento +
                '}';
    }
}

```

```java
package Listas;

public class Lista<E> {

    private Nodo cabecera;
    private int tamano;

    public Lista(){
        this.cabecera = null;
        this.tamano = 0;
    }

    public E get(int posicion){
        if (posicion < 0 || posicion > this.tamano){
            throw new IndexOutOfBoundsException("Fora de rango");
        }
        Nodo res = this.cabecera;
        for (int i = 0; i<posicion; i++)
            res = res.getSiguiente();
        return (E) res.getElemento();
    }

    public boolean add(E elemento, int posicion){
        if (posicion < 0 || posicion > this.tamano){
            return false;
        }
        Nodo<E> nuevo = new Nodo(elemento);
        if (posicion==0){
            nuevo.setSiguiente(this.cabecera);
            this.cabecera = nuevo;
        } else {
            Nodo<E> anterior = (Nodo) this.cabecera;
            for (int i = 0; i<posicion-1; i++)
                anterior = anterior.getSiguiente();
            Nodo<E> siguiente = (Nodo) anterior.getSiguiente();
            nuevo.setSiguiente(siguiente);
            anterior.setSiguiente(nuevo);
        }
        this.tamano++;
        return true;
    }

    public boolean eliminar(E elemento){
        if (this.tamano==0)
            return false;
        if (this.cabecera.equals(elemento)){
            this.cabecera = this.cabecera.getSiguiente();
            this.tamano--;
            return true;
        }
        Nodo<E> actual = (Nodo) this.cabecera;
        while (actual.getSiguiente()!=null){
            if(actual.getSiguiente().getElemento().equals(elemento)){
                actual.setSiguiente(actual.getSiguiente().getSiguiente());
                this.tamano--;
                return true;
            }
            actual = (Nodo) actual.getSiguiente();
        }
        return false;
    }

    @Override
    public String toString() {
        if (this.tamano==0)
            return "Lista[]";
        String res = "Lista[";
        Nodo<E> actual = (Nodo) this.cabecera;
        for (int i = 0; i<this.tamano; i++){
            res += actual.getElemento();
            if (actual.getSiguiente()!=null)
                res+=",";
            actual = actual.getSiguiente();
        }
        res+="]";
        return res;
    }
}

```

```java
package Listas;

public class App {
    public static void main(String[] args) {
        Lista<String> cidades = new Lista<>();

        System.out.println("--- Engadindo cidades ---");
        cidades.add("A Coruña", 0);
        cidades.add("Vigo", 1);
        cidades.add("Lugo", 1); // Debería quedar no medio
        cidades.add("Ourense", 0); // Debería ser a nova cabeza

        System.out.println(cidades.toString());
        // Esperado: Lista[Ourense, A Coruña, Lugo, Vigo]

        System.out.println("\n--- Probando búsqueda ---");
        System.out.println("Cidade na posición 2: " + cidades.get(2)); // Lugo

        System.out.println("\n--- Probando eliminación ---");
        System.out.println("Eliminando Lugo... " + (cidades.eliminar("Lugo") ? "Éxito" : "Erro"));
        System.out.println("Eliminando Santiago (non existe)... " + (cidades.eliminar("Santiago") ? "Éxito" : "Erro"));

        System.out.println("\nEstado final:");
        System.out.println(cidades.toString());
        System.out.println("Tamaño final: " + cidades.get(0).getClass().getSimpleName() + " con " + cidades.toString().split(",").length + " elementos reais.");
    }
}
```

3. Lista doblemente enlazada:
   1. A clase Nodo debe de incluir un atributo denominado anterior de tipo Nodo, que apunte ao Nodo anterior
   2. Para poder empregar de forma mais potente esta estructura, adoita definirse un punteiro ao último elemento da lista e ordenar o seu contido, para poder recorrela de atras adiante e de adiante cara atrás.
   3. Ao engadir un elemento, hai que xestionar catro punteiros:
      1. O seguinte de NodoNovo apunta a NodoSeguinte
      2. O anterior de NodoNovo apunta a NodoAnterior
      3. O  seguinte do NodoAnterior apunta a NodoNovo
      4. O anterior de NodoSeguinte apunta a NodoNovo
      5. Compre ter en conta que
         1. O anterior do primeiro e NULL
         2. O seguinte do último e NULL
   4. Ao eliminar un elemento, basta con desenganchalo da lista:
      1. O seguinte do NodoAnterior pasa a ser o NodoSeguinte
         1. Se o nodo eliminado é o último, hai que ter coidado por que é un valor nulo. Este caso haino que xestionar aparte.&#x20;
      2. O anterior do NodoSeguinte, pasa a ser o NodoAnterior
         1. Se o nodo eliminado é o primerior, hai que ter coidado por que é un valor nulo. Este caso haino que xestionar aparte.
   5. O recorrido pode facerse cara adiante ou cara atrás, en función do buscado.
4. Lista Circular:

   1. A clase Nodo e a clase Lista non sofren cambios na súa estructura, pero a sua lóxica varía, o último nodo apunta a cabeceira en lugar de a null.
   2. Ao engadir un elemento, hai que ter en conta o seguinte:
      1. Se a lista está baileira, o seguinte do NodoNovo debe de ser o propio NodoNovo
      2. Se insertamos en primeira posición, o seguinte do ultimo elemento pasa a ser o NodoNovo, e a cabeceira da lista pasa a ser o NodoNovo
      3. Se insertamos en ultima posición, o seguinte do Elemento insertado e o elemento de cabeceira
      4. As insercións intermedias comportanse como as insercións anteriores
   3. Ao eliminar un elemento, basta con "desenganchalo" igual que nos casos anteriores:
      1. Se eliminas o primeiro nodo, hai que recorrer toda a lista para que o seguinte nodo do ultimo sexa a nova cabeceira
   4. Ao recorrer a lista, hai que controlar se o nodo seguinte e o nodo de cabeceira. Se é asi, finalizamos o recorrido


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://educacion.gitbook.io/programacion/exercicios-java/ud6-solucions/listas.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.