Introducción

1

¬ŅYa tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?

Lista Enlazada

2

Estructura de datos: Lista Enlazada

3

Programando listas enlazadas con Java

4

Cómo Invertir una Lista Enlazada

5

Odd Even Linked List: an√°lisis del problema

6

Solución de Odd Even Linked List

7

Playground: Odd Even Liked List

8

Programando Odd Even Linked List con C++

9

Linked List Cycle: an√°lisis del problema

10

Solución de Linked List Cycle

11

Playground: Linked List Cycle

12

Programando Linked List Cycle con Python

13

Palindrome Linked List: an√°lisis del problema

14

Solución de Palindrome Linked List

15

Playground: Palindrome Linked List

16

Programando Palindrome Linked List con Java

17

Reorder List: an√°lisis del problema

18

Solución de Reorder List

19

Programando Reorder List con JavaScript

20

Playground: Reorder List Without Repeated Values

21

Reto: LRU Caché

22

Ejercicios recomendados de Lista Enlazada

23

Ejercicios resueltos de Lista Enlazada

Pilas y colas

24

Estructura de datos: Pilas y Colas

25

Paréntesis Válido: análisis del problema

26

Solución de Paréntesis Válido

27

Playground: Paréntesis Válido

28

Programando Paréntesis Válido con C++

29

Ejercicios recomendados de Pilas

Colas de prioridad

30

Estructura de datos: Colas de Prioridad

31

K Closest Points to Origin: an√°lisis del problema

32

Solución de K Closest Points to Origin

33

Playground: K Closest Points to Origin

34

Programando K Closest Points to Origin con Python

35

Reorganize String: an√°lisis del problema

36

Solución de Reorganize String

37

Playground: Reorganize String

38

Programando Reorganize String con Python

39

Ejercicios recomendados de Colas de prioridad

40

Ejercicios resueltos de Colas de prioridad

Próximos pasos

41

Toma el Curso Avanzado de Algoritmos: Grafos y √Ārboles

No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Programando listas enlazadas con Java

3/41
Recursos

Aportes 8

Preguntas 2

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

Los métodos de borrarNodo y borrarNodoPorValor al hacer el .siguiente = null; no borra el nodo sino que lo desconecta (borra) la referencia de ahí en adelante. Es necesario tener un apuntador en el anterior para conectarlo al siguiente y no perder el resto de la lista.

Si lo estas haciendo en java y tambien tuviste la duda de porque la profe no usa parentesis y eso en el metodo buscarNodo aqui el codigo corregido: ```js public Nodo buscarNodo(int valorABuscar) { Nodo nodoActual = cabeza; while (nodoActual != null) { if (nodoActual.valor == valorABuscar) { return nodoActual; } nodoActual = nodoActual.siguiente; } return null; } ```public Nodo buscarNodo(int valorABuscar) { Nodo nodoActual = cabeza; while (nodoActual != null) { if (nodoActual.valor == valorABuscar) { return nodoActual; } nodoActual = nodoActual.siguiente; } return null; } ![](https://static.platzi.com/media/user_upload/image-a1e9ed8d-a285-4fbc-85db-7b59531386b6.jpg)
por lo que entiendo del ejercicio: borrarNodo y borrarNodoPorValor, no están borrando el nodo especificado, sino que están borrando los enlaces desde el nodo especificado hacia otros nodo (siguiente). Para borrar el nodo especificado, se debería buscar todos los nodos, cuyo "siguiente" apunta al nodo especificado, asignarle null (desvincularlo)

Para los que necesiten el código en Python:

https://github.com/NarcisaColcha/Lista-Enlazada-Simple

Una visualización del porque está incompleto el método borrarNodo y borrarNodoPorValor, si la lista fuera:
0 -> 1 -> 2 -> 3 y quisiera eliminar el 1, obtendríamos:
0 -> 1, el resto lo perderíamos ya que no hicimos una conexión (.siguiente) al resto de la lista que estaba después del nodo a eliminar (2 -> 3), para que luego el 0 apunte al resto de la lista.

Muchos la conocen, pero para hacer pruebas y entender mejor us:

https://pythontutor.com/render.html#mode=display

Tambien comparto el código en python, pero modificándole el delate, porque el de la profe tiene un Bug o al menos al pasarlo a python no elimina bien:

  • para hacer pruebas:
# Create a new linked list with the first node
first_node = Node(1)
linked_list = LinkedList(first_node)
# Insert a new node at the end of the linked lis
second_node = Node(2)
linked_list.insert_node_at_end(second_node)
found_node = linked_list.search_node(2)
print(found_node.value)
linked_list.delete_node_by_value(2)
found_node = linked_list.search_node(2)
print(found_node) # This should print None

Solución más compleja en Java mismo del método borrarNodoPorValor y para ir observando cómo va quedando la lista sobreescribí el método toString, ambos van en la clase ListaEnlazada:

    public void borrarNodoPorValor(int valor) {
        
        if (cabeza == null) { // Si la lista enlazada está vacía
            System.out.println("El nodo no pudo ser borrado porque la ListaEnlazada está vacía.");
        } else {
            Nodo nodoABorrar = buscarNodo(valor);

            if (nodoABorrar != null) {
                Nodo nuevo = null;

                if ((cabeza.equals(cola))) { // Si la lista enlazada tiene solo 1 nodo
                    cabeza = null;
                    System.out.println("ListaEnlazada ahora está vacía.");    
                } else if (nodoABorrar == cabeza) {
                    nuevo = cabeza.siguiente;
                    nodoABorrar.siguiente = null;
                    cabeza = nuevo;
                    cabeza.siguiente = nuevo.siguiente;                
                } else {   // Cualquier nodo después de cabeza, incluido cola

                    Nodo nodoAnterior = null;
                    Nodo nodoActual = cabeza;
                    
                    while(nodoActual.siguiente != null) {
                        nodoAnterior = nodoActual;
                        nodoActual = nodoActual.siguiente;
                        if ((nodoActual == nodoABorrar) && (nodoABorrar != cola)) {
                            break;
                        }
                    }                       
                        
                    if (nodoABorrar != cola) {
                        nodoAnterior.siguiente = nodoActual.siguiente;
                        nodoActual.siguiente = null;
                        nodoActual = null;
                    } else {                    // Si es igual a cola
                        cola = nodoAnterior;
                        cola.siguiente = null;
                    }
                } 
            } else {
                System.out.println("Nodo no existente.");
            }
        }    
    }
    
    
    @Override
    public String toString() {
        if (cabeza == null) { //Si la lista en vacía
            return "ListaEnlazada{}";
        } else if (cabeza != null && cabeza == cola) { // Si la lista tiene solo 1 elemento
            return "ListaEnlazada{cabeza:" + cabeza.valor + ", cola: " + cola.valor + "}";
        }
        return "ListaEnlazada{cabeza=" + cabeza.valor + ", cabeza.siguiente=" + cabeza.siguiente.valor + ", cola=" + cola.valor + "}";
    }

Hola , Muy bueno el comienzo , pero estaría bueno que haya una pausa creando nodos (haciendo correr código del nodo ) y después pasar a la class ListaEnlazada .

Creo que el método borrarNodoPorValor podria utilizar el método borrarNodo que ya tenemos

public void borrarNodoPorValor(int valor){
	nodoABorrar = buscarNodo(valor);
	if(nodoABorrar != null){
		borrarNodo(nodoABorrar);
	}
}