Listas enlazadas en detalle con ejemplos de Python: Listas enlazadas simples

    Las listas enlazadas son una de las estructuras de datos más utilizadas en cualquier lenguaje de programación. En este artículo, estudiaremos las listas enlazadas en detalle. Veremos cuáles son los diferentes tipos de listas enlazadas, cómo recorrer una lista enlazada, cómo insertar y eliminar elementos de una lista enlazada, cuáles son las diferentes técnicas para ordenar una lista enlazada, cómo revertir una lista enlazada, etc. .

    Después de leer este artículo, debería poder descifrar todas las preguntas de la entrevista de la lista vinculada.

    ¿Qué es una lista vinculada?

    Antes de estudiar qué son las listas vinculadas, primero revisemos brevemente cómo las matrices almacenan datos. En las matrices, los datos se almacenan en ubicaciones de memoria contiguas. Por ejemplo, si el primer elemento de la matriz se almacena en el índice 10 de la memoria y tiene un tamaño de 15 bytes, el segundo elemento se almacenará en el índice 10 + 15 + 1 = índice 26. Por lo tanto, es sencillo atravesar una matriz.

    Para encontrar el tercer elemento en una matriz, simplemente puede usar el índice inicial del primer elemento, más el tamaño del primer elemento, más el tamaño del segundo elemento, más 1.

    Cómo almacenan datos las listas enlazadas

    Las listas enlazadas, por otro lado, son diferentes. Listas vinculadas, no almacenan datos en ubicaciones de memoria contiguas. Para cada elemento en la ubicación de la memoria, la lista vinculada almacena el valor del elemento y la referencia o puntero al siguiente elemento. Un par del elemento de la lista enlazada y la referencia al siguiente elemento constituyen un node.

    Por ejemplo, si un node consta de 34 | 10, significa que el valor del node es 30, mientras que el siguiente elemento se almacena en la ubicación de memoria “10”. Para recorrer una lista vinculada, solo necesita conocer la ubicación de la memoria o la referencia del primer node, el resto de nodes se pueden recorrer secuencialmente usando la referencia al siguiente elemento en cada node.

    La referencia al primer node también se conoce como node de inicio.

    Listas vinculadas frente a matrices:

    • Una lista vinculada es una estructura de datos dinámica, lo que significa que la memoria reservada para la lista de vínculos se puede aumentar o reducir en tiempo de ejecución. No se asigna memoria para una estructura de datos de lista enlazada de antemano. Siempre que se requiera agregar un nuevo elemento al enlace, la memoria para el nuevo node se crea en tiempo de ejecución. Por otro lado, en el caso de la matriz, la memoria debe asignarse por adelantado para un número específico de elementos. En los casos en que no hay suficientes elementos disponibles para llenar todo el índice de la matriz, se desperdicia espacio de memoria.
    • Dado que las matrices requieren ubicaciones de memoria contiguas, es muy difícil quitar o insertar un elemento en una matriz, ya que las ubicaciones de memoria de una gran cantidad de elementos deben actualizarse. Por otro lado, los elementos de la lista vinculada no se almacenan en una ubicación de memoria contigua, por lo que puede actualizar fácilmente las listas vinculadas.
    • Debido a su flexibilidad, una lista vinculada es más adecuada para implementar estructuras de datos como pilas, colas y listas.

    Sin embargo, también hay algunas desventajas en la lista vinculada.

    • Dado que cada elemento de la lista vinculada tiene que almacenar la referencia al siguiente elemento, se requiere algo de memoria adicional.
    • A diferencia de las matrices, donde puede acceder directamente a un elemento, no puede acceder directamente a un elemento de la lista vinculada ya que la única información que tiene es la referencia al primer elemento. En términos de Big O, el tiempo de acceso en el peor de los casos es O (n).

    En esta serie de artículos, estudiaremos los siguientes tipos de listas enlazadas junto con sus diferentes funcionalidades.

    • Lista vinculada única
    • Lista doblemente vinculada
    • Lista enlazada circular
    • Lista vinculada con encabezado
    • Lista vinculada ordenada

    En esta primera parte del artículo, nos centraremos en la lista enlazada única y sus diferentes operaciones.

    Lista vinculada única
    Creación de la clase de node
    Creación de la clase de lista vinculada única
    Recorrido de elementos de lista vinculada
    Insertar elementos
    Contar elementos
    Buscar elementos
    Crear una lista vinculada
    Eliminar elementos
    Invertir una lista vinculada

    Lista vinculada única

    Una sola lista vinculada es la más simple de todas las variantes de listas vinculadas. Cada node en una única lista vinculada contiene un elemento y una referencia al siguiente elemento y eso es todo.

    En esta sección, veremos cómo crear un node para la lista vinculada única junto con las funciones para los diferentes tipos de inserción, recorrido y eliminación.

    Crear la clase de node

    Lo primero que debe hacer es crear una clase para los nodes. Los objetos de esta clase serán los nodes reales que insertaremos en nuestra lista vinculada. Sabemos que un node para una sola lista vinculada contiene el elemento y la referencia al siguiente node. Por lo tanto, nuestra clase de node contendrá dos variables miembro itemy ref. El valor de itemse establecerá mediante el valor pasado a través del constructor, mientras que la referencia se establecerá inicialmente en nulo.

    Ejecute el siguiente script:

    class Node:
        def __init__(self, data):
            self.item = data
            self.ref = None
    

    Creación de la clase de lista vinculada única

    A continuación, necesitamos crear una clase para la Lista vinculada. Esta clase contendrá los métodos para insertar, eliminar, recorrer y ordenar la lista. Inicialmente, la clase solo contendrá un miembro start_nodeque apuntará al inicio o al primer node de la lista. El valor de start_nodese establecerá en nulo utilizando el constructor, ya que la lista vinculada estará vacía en el momento de la creación. El siguiente script crea una clase para la lista vinculada.

    class LinkedList:
        def __init__(self):
            self.start_node = None
    

    Ahora hemos creado una clase para nuestra lista única. El siguiente paso es agregar la función de inserción para insertar elementos en la lista vinculada. Pero antes de eso, agregaremos una función para recorrer una lista vinculada. Esta función nos ayudará a leer los datos de nuestra lista.

    Atravesar elementos de lista vinculados

    El código de Python para la función transversal es el siguiente. Agregue la función a continuación a la LinkedListclase que creamos en la última sección.

    def traverse_list(self):
        if self.start_node is None:
            print("List has no element")
            return
        else:
            n = self.start_node
            while n is not None:
                print(n.item , " ")
                n = n.ref
    

    Veamos qué está sucediendo en la función anterior. La función tiene dos partes principales. Primero, verifica si la lista vinculada está vacía o no. El siguiente código comprueba que:

      if self.start_node is None:
            print("List has no element")
            return
    

    Si la lista vinculada está vacía, eso significa que no hay ningún elemento para iterar. En tales casos, la traverse_list()función simplemente imprime la declaración de que la lista no tiene ningún elemento.

    De lo contrario, si la lista tiene un elemento, se ejecutará el siguiente código:

        n = self.start_node
            while n is not None:
                print(n.item , " ")
                n = n.ref
    

    Como dijimos anteriormente, la startvariable contendrá una referencia a los primeros nodes. Por lo tanto, inicializamos una variable ncon startvariable. A continuación, ejecutamos un ciclo que se ejecuta hasta que se nconvierte en ninguno. Dentro del ciclo, imprimimos el elemento almacenado en el node actual y luego establecemos el valor de la nvariable en n.ref, que contiene la referencia al siguiente node. La referencia del último node es Noneporque no hay ningún node después de eso. Por lo tanto, cuando se nconvierte en None, el bucle termina.

    Ahora, tenemos una función para recorrer una lista vinculada, veamos cómo podemos agregar elementos a una sola lista vinculada.

    Insertar elementos

    Dependiendo de la ubicación donde desee insertar un elemento, existen diferentes formas de insertar elementos en una única lista vinculada.

    Insertar elementos al principio

    La forma más sencilla de insertar un elemento en una única lista vinculada es agregar un elemento al principio de la lista. La siguiente función inserta un elemento al principio de la lista. Agregue esta función a la LinkedListclase que creamos anteriormente.

        def insert_at_start(self, data):
            new_node = Node(data)
            new_node.ref = self.start_node
            self.start_node= new_node
    

    En el script anterior, creamos un método insert_at_start(), el método acepta un parámetro, que es básicamente el valor del elemento que queremos insertar. Dentro del método, simplemente creamos un objeto de la Nodeclase y establecemos su referencia al start_nodeya que start_nodeanteriormente estaba almacenando el primer node, que después de la inserción de un nuevo node al inicio se convertirá en el segundo node.

    Por lo tanto, agregamos la referencia de start_nodea la refvariable del nuevo node. Ahora que new_nodees el primer node, establecemos el valor de la start_nodevariable en new_node.

    Insertar elementos al final

    La siguiente función se utiliza para agregar un elemento al final de la lista vinculada.

      def insert_at_end(self, data):
            new_node = Node(data)
            if self.start_node is None:
                self.start_node = new_node
                return
            n = self.start_node
            while n.ref is not None:
                n= n.ref
            n.ref = new_node;
    

    En el script anterior, creamos una función insert_at_end(), que inserta el elemento al final de la lista vinculada. El valor del elemento que queremos insertar se pasa como argumento a la función. La función consta de dos partes. Primero comprobamos si la lista enlazada está vacía o no, si la lista enlazada está vacía, todo lo que tenemos que hacer es establecer el valor de la start_nodevariable en new_nodeobjeto.

    Por otro lado, si la lista ya contiene algunos nodes. Inicializamos una variable ncon el node de inicio. Luego iteramos a través de todos los nodes en la lista usando un ciclo while como hicimos en el caso de la traverse_listfunción. El ciclo termina cuando llegamos al último node. Luego establecemos la referencia del último node al recién creado new_node.

    Agrega la insert_at_end()función a la LinkedListclase.

    Insertar artículo después de otro artículo

    Es posible que necesitemos agregar un elemento después de otro elemento en una sola lista vinculada. Para hacerlo, podemos usar la insert_after_item()función como se define a continuación:

        def insert_after_item(self, x, data):
    
            n = self.start_node
            print(n.ref)
            while n is not None:
                if n.item == x:
                    break
                n = n.ref
            if n is None:
                print("item not in the list")
            else:
                new_node = Node(data)
                new_node.ref = n.ref
                n.ref = new_node
    

    La insert_after_item()función acepta dos parámetros: xy data. El primer parámetro es el elemento después del cual desea insertar el nuevo node, mientras que el segundo parámetro contiene el valor del nuevo node.

    Comenzamos creando una nueva variable ny asignándole una start_nodevariable. A continuación, recorremos la lista vinculada usando el bucle while. El ciclo while se ejecuta hasta que se nconvierte en None. Durante cada iteración, verificamos si el valor almacenado en el node actual es igual al valor pasado por el xparámetro. Si la comparación devuelve verdadera, rompemos el ciclo.

    A continuación, si se encuentra el elemento, la nvariable no lo será None. La referencia de new_nodese establece en la referencia almacenada por ny la referencia de nse establece en new_node. Agrega la insert_after_item()función a la LinkesListclase.

    Insertar artículo antes que otro artículo

        def insert_before_item(self, x, data):
            if self.start_node is None:
                print("List has no element")
                return
    
            if x == self.start_node.item:
                new_node = Node(data)
                new_node.ref = self.start_node
                self.start_node = new_node
                return
    
            n = self.start_node
            print(n.ref)
            while n.ref is not None:
                if n.ref.item == x:
                    break
                n = n.ref
            if n.ref is None:
                print("item not in the list")
            else:
                new_node = Node(data)
                new_node.ref = n.ref
                n.ref = new_node
    

    En el script de arriba definimos la insert_before_item()función. La función tiene tres partes. Veamos cada parte en detalle.

         if self.start_node is None:
            print("List has no element")
            return
    

    En el script anterior, verificamos si la lista está vacía. Si está realmente vacío, simplemente imprimimos que la lista no tiene ningún elemento y regresamos de la función.

    A continuación, comprobamos si el elemento se encuentra en el primer índice. Mira el siguiente guión:

         if x == self.start_node.item:
            new_node = Node(data)
            new_node.ref = self.start_node
            self.start_node = new_node
            return
    

    Si el elemento después del cual queremos insertar un nuevo node se encuentra en el primer índice. Simplemente establecemos la referencia del node recién insertado en start_nodey luego establecemos el valor de start_nodeen new_node.

    Finalmente, si la lista no lo es Noney el elemento no se encuentra en el primer índice, creamos una nueva variable ny le asignamos una start_nodevariable. A continuación, recorremos la lista vinculada usando el bucle while. El ciclo while se ejecuta hasta que se n.refconvierte en None. Durante cada iteración, verificamos si el valor almacenado en la referencia del node actual es igual al valor pasado por el xparámetro. Si la comparación devuelve verdadera, rompemos el ciclo.

    A continuación, si se encuentra el elemento, la n.refvariable no lo será None. La referencia de new_nodese establece en referencia de ny la referencia de nse establece en new_node. Mira el siguiente guión:

        if n.ref is None:
            print("item not in the list")
        else:
            new_node = Node(data)
            new_node.ref = n.ref
            n.ref = new_node
    

    Agrega una insert_before_item()función a la LinkedListclase.

    Insertar artículo en índice específico

    A veces, necesitamos insertar un elemento en un índice específico, podemos hacerlo con la ayuda del siguiente script:

        def insert_at_index (self, index, data):
            if index == 1:
                new_node = Node(data)
                new_node.ref = self.start_node
                self.start_node = new_node
            i = 1
            n = self.start_node
            while i < index-1 and n is not None:
                n = n.ref
                i = i+1
            if n is None:
                print("Index out of bound")
            else: 
                new_node = Node(data)
                new_node.ref = n.ref
                n.ref = new_node
    

    En el script, primero verificamos si el índice en el que queremos almacenar el elemento es 1, luego simplemente asignamos start_nodea la referencia de new_nodey luego establecemos el valor de start_nodea new_node.

    A continuación, ejecute un ciclo while que se ejecutará hasta que el contador isea ​​mayor o igual que el index-1. Por ejemplo, si desea agregar un nuevo node al tercer índice. Durante la primera iteración del ciclo while, ise convertirá en 2 y el node actualmente iterado será ‘2’. El bucle no se ejecutará de nuevo ya ique ahora es 2, que es igual a index-1 (3-1 = 2). Por lo tanto, el bucle se romperá. A continuación, agregamos un nuevo node después del node actualmente iterado (que es el node 2), por lo tanto, el nuevo node se agrega en el índice.

    Es importante mencionar que si el índice o la ubicación pasada como argumento es mayor que el tamaño de la lista vinculada, se le mostrará al usuario un mensaje que indica que el índice está fuera de rango o fuera de límite.

    Prueba de funciones de inserción

    Ahora que hemos definido todas nuestras funciones de inserción, probémoslas.

    Primero, cree un objeto de la clase de lista vinculada de la siguiente manera:

    new_linked_list = LinkedList()
    

    A continuación, primero llamemos a la insert_at_end()función para agregar tres elementos a la lista vinculada. Ejecute el siguiente script:

    new_linked_list.insert_at_end(5)
    new_linked_list.insert_at_end(10)
    new_linked_list.insert_at_end(15)
    

    Para ver si los elementos se han insertado realmente, recorramos la lista vinculada usando la función de recorrido.

    new_linked_list.traverse_list()
    

    Debería ver el siguiente resultado:

    5
    10
    15
    

    A continuación, agreguemos un elemento al principio:

    new_linked_list.insert_at_start(20)
    

    Ahora, si recorre la lista, debería ver el siguiente resultado:

    20
    5
    10
    15
    

    Agreguemos un nuevo elemento 17 después del elemento 10:

    new_linked_list.insert_after_item(10, 17)
    

    Atravesar la lista devuelve ahora la siguiente salida:

    20
    5
    10
    17
    15 
    

    Puede ver 17 insertados después de 10.

    Insertemos ahora otro elemento 25 antes del elemento 17 usando la insert_before_item()función como se muestra a continuación:

    new_linked_list.insert_before_item(17, 25)
    

    Ahora la lista contendrá los siguientes elementos:

    20
    5
    10
    25
    17
    15
    

    Finalmente, agreguemos un elemento en la tercera ubicación, que actualmente está ocupada por 10. Verá que 10 moverá una ubicación hacia adelante y el nuevo elemento se insertará en su lugar. La insert_at_index()función se puede utilizar para este propósito. El siguiente script inserta el elemento 8en el índice del tercer índice de la lista.

    new_linked_list.insert_at_index(3,8)
    

    Ahora, si recorre la lista, debería ver el siguiente resultado:

    20
    5
    8
    10
    25
    17
    15
    

    Y con eso, hemos probado todas nuestras funciones de inserción. Actualmente tenemos 7 elementos en nuestra lista. Escribamos una función que devuelva el número de elementos en una lista vinculada.

    Contando elementos

    La siguiente función cuenta el número total de elementos.

        def get_count(self):
            if self.start_node is None:
                return 0;
            n = self.start_node
            count = 0;
            while n is not None:
                count = count + 1
                n = n.ref
            return count
    

    En el script anterior creamos una get_count()función que simplemente cuenta el número de elementos en la lista vinculada. La función simplemente atraviesa todos los nodes de la matriz e incrementa un contador usando el bucle while. Al final del ciclo, el contador contiene el número total de elementos en el ciclo.

    Agregue la función anterior a la LinkedListclase, compile la LinkedListclase y luego inserte algunos elementos en el LinkedListcomo hicimos en la última sección. Teníamos 7 elementos en nuestra lista vinculada, al final de la última sección.

    Usemos la get_count()función para obtener el número total de elementos en la lista:

    new_linked_list.get_count()
    

    Debería ver la cantidad de elementos en su lista vinculada en la salida.

    Alternativamente, otra forma de obtener el ‘recuento’ de la lista sería rastrear el número de elementos insertados y eliminados de la lista en una simple variable de contador perteneciente a la LinkedListclase. Esto funciona bien y es más rápido que el get_countmétodo anterior, si la estructura de datos de la lista subyacente no se puede manipular desde fuera de la clase.

    Elementos de búsqueda

    La búsqueda de un elemento es bastante similar a contar o recorrer una lista vinculada, todo lo que tiene que hacer es comparar el valor que se buscará con el valor del node durante cada iteración. Si se encuentra el valor, imprima que se encuentra el valor y rompa el ciclo. Si el elemento no se encuentra después de atravesar todos los nodes, simplemente imprima que el elemento no se encuentra.

    El guión para el search_item()es el siguiente:

        def search_item(self, x):
            if self.start_node is None:
                print("List has no elements")
                return
            n = self.start_node
            while n is not None:
                if n.item == x:
                    print("Item found")
                    return True
                n = n.ref
            print("item not found")
            return False
    

    Agregue la función anterior a la LinkedListclase. Busquemos un elemento en la lista creada anteriormente. Ejecute el siguiente script:

    new_linked_list.search_item(5)
    

    Dado que insertamos 5 en nuestra lista vinculada, la función anterior devolverá verdadero. La salida se verá así:

    Item found
    True
    

    Crear una lista vinculada

    Aunque podemos agregar elementos uno por uno usando cualquiera de las funciones de inserción. Creemos una función que le pida al usuario que ingrese la cantidad de elementos en el node y luego el elemento individual e ingrese ese elemento en la lista vinculada.

        def make_new_list(self):
            nums = int(input("How many nodes do you want to create: "))
            if nums == 0:
                return
            for i in range(nums):
                value = int(input("Enter the value for the node:"))
                self.insert_at_end(value)
    

    En el script anterior, la make_new_list()función primero le pide al usuario el número de elementos de la lista. Luego, usando un bucle for, se le pide al usuario que ingrese el valor para cada node, que luego se inserta en la lista vinculada usando la insert_at_end()función.

    La siguiente captura de pantalla muestra la make_new_list()función en acción.

    Eliminar elementos

    En esta sección, veremos las diferentes formas de eliminar un elemento de una única lista vinculada.

    Eliminación desde el inicio

    Eliminar un elemento o elemento desde el principio de la lista vinculada es sencillo. Tenemos que establecer la referencia del start_nodeal segundo node, lo que podemos hacer simplemente asignando el valor de la referencia del node de inicio (que apunta al segundo node) al node de inicio como se muestra a continuación:

        def delete_at_start(self):
            if self.start_node is None:
                print("The list has no element to delete")
                return 
            self.start_node = self.start_node.ref
    

    En el script anterior, primero verificamos si la lista está vacía o no. Si la lista está vacía mostramos el mensaje de que la lista no tiene ningún elemento para eliminar. De lo contrario, asignamos el valor de start_node.refal start_node. El start_nodeahora apuntará hacia el segundo elemento. Agrega la delete_at_start()función a la LinkedListclase.

    Eliminación al final

    Para eliminar un elemento del final de la lista, simplemente tenemos que iterar a través de la lista enlazada hasta el penúltimo elemento, y luego debemos establecer la referencia del penúltimo elemento a ninguno, lo que convertirá el penúltimo elemento a último elemento.

    El script de la función delete_at_endes el siguiente:

        def delete_at_end(self):
            if self.start_node is None:
                print("The list has no element to delete")
                return
    
            n = self.start_node
            while n.ref.ref is not None:
                n = n.ref
            n.ref = None
    

    Agregue el script anterior a la LinkedList()clase.

    Eliminación por valor de artículo

    Para eliminar el elemento por valor, primero tenemos que encontrar el node que contiene el elemento con el valor especificado y luego eliminar el node. Encontrar el elemento con el valor especificado es bastante similar a buscar el elemento. Una vez que se encuentra el elemento que se va a eliminar, la referencia del node antes del elemento se establece en el node que existe después del elemento que se elimina. Mira el siguiente guión:

      def delete_element_by_value(self, x):
        if self.start_node is None:
            print("The list has no element to delete")
            return
    
        # Deleting first node 
        if self.start_node.item == x:
            self.start_node = self.start_node.ref
            return
    
        n = self.start_node
        while n.ref is not None:
            if n.ref.item == x:
                break
            n = n.ref
    
        if n.ref is None:
            print("item not found in the list")
        else:
            n.ref = n.ref.ref
    

    En el script anterior, primero verificamos si la lista está vacía. A continuación, comprobamos si el elemento a eliminar se encuentra al inicio de la lista enlazada. Si el elemento se encuentra al principio, lo eliminamos estableciendo el primer node en la referencia del primer node (que básicamente se refiere al segundo node).

    Finalmente, si el elemento no se encuentra en el primer índice, iteramos a través de la lista vinculada y verificamos si el valor del node que se itera es igual al valor que se eliminará. Si la comparación devuelve verdadera, establecemos la referencia del node anterior al node que existe después del node que se está eliminando.

    Prueba de funciones de eliminación

    Probemos las funciones de eliminación que acabamos de crear. Pero antes de eso, agregue algunos datos ficticios a nuestra lista vinculada usando el siguiente script:

    new_linked_list.insert_at_end(10)
    new_linked_list.insert_at_end(20)
    new_linked_list.insert_at_end(30)
    new_linked_list.insert_at_end(40)
    new_linked_list.insert_at_end(50)
    

    El script anterior inserta 5 elementos en una lista vinculada. Si recorre la lista, debería ver los siguientes elementos:

    10
    20
    30
    40
    50
    

    Primero eliminemos un elemento desde el principio:

    new_linked_list.delete_at_start()
    

    Ahora, si recorre la lista, debería ver el siguiente resultado:

    20
    30
    40
    50 
    

    Eliminemos un elemento del final ahora:

    new_linked_list.delete_at_end()
    

    La lista ahora contiene los siguientes elementos:

    20
    30
    40
    

    Finalmente, eliminemos un elemento por valor, digamos 30.

    new_linked_list.delete_element_by_value(30)
    

    Ahora, si recorre la lista, no debería ver el elemento 30.

    Inversión de una lista vinculada

    Para invertir una lista vinculada, debe tener tres variables prev, ny next. El prevhará un seguimiento del node anterior, el nexthará un seguimiento del siguiente node ny corresponderá al node actual.

    Comenzamos un ciclo while asignando el node inicial a la variable ny la prevvariable se inicializa a none. El ciclo se ejecuta hasta que se nconvierte en ninguno. Dentro del ciclo while, debe realizar las siguientes funciones.

    • Asignar el valor de la referencia del node actual a next.
    • Establezca el valor de referencia del node actual nalprev
    • Establece la prevvariable en el node actual n.
    • Establezca el node actual nen el valor de nextnode.

    Al final del ciclo, la prevvariable apuntará al último node, necesitamos convertirlo en el primer node, por lo que establecemos la self.start_nodevariable de valor en prev. El bucle while hará que cada node apunte a su node anterior, lo que dará como resultado una lista enlazada invertida. El guión es el siguiente:

        def reverse_linkedlist(self):
            prev = None
            n = self.start_node
            while n is not None:
                next = n.ref
                n.ref = prev
                prev = n
                n = next
            self.start_node = prev
    

    Agregue la función anterior a la LinkedListclase. Cree una lista vinculada de números aleatorios y luego vea si puede revertirla usando la reverse_linkedlist()función.

    Conclusión

    En este artículo, comenzamos nuestra discusión sobre una sola lista vinculada. Vimos cuáles son las diferentes funciones que se pueden realizar en la lista vinculada, como recorrer una lista vinculada, insertar elementos en una lista vinculada, buscar y contar elementos de la lista vinculada, eliminar elementos de una lista vinculada y revertir una sola lista vinculada.

    Esta es la Parte 1 de la serie de artículos de la lista vinculada. En la siguiente parte (próximamente), veremos cómo ordenar una sola lista vinculada, cómo fusionar listas vinculadas ordenadas y cómo eliminar ciclos de una sola lista vinculada.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *