Operaciones en single linked structures

Cuando el profesor solo hace una narrativa del código que esta escribiendo, ya la clase no es educativa, para que entendamos bien lo que estamos haciendo en especial en esta clase es mostrar así estaba y asi quedo despues de tal operación, en lo personal logre finalizar la clase con muchos baches, y para reforzar no es repasar el video sino ir a buscar a youtube alguien que si lo pueda explicar mejor, y que lastima porque uno paga para evitar la busqueda y tener una ruta mas limpia.

creo que esta clase esta muy apresurada, mucho codigo y nada de ejemplos practicos, para entender mejor

El código presentado, divido por comentarios, y con sus respectivas salidas.

from node import Node

# * Creación de los nodos enlazados (linked list)
head = None
for count in range(1,6):
    head = Node(count, head)

# * Recorrer e imprimir valores de la lista
probe = head
print("Recorrido de la lista:")
while probe != None:
    print(probe.data)
    probe = probe.next

Recorrido de la lista:
5
4
3
2
1

# * Busqueda de un elemento
probe = head
target_item = 2
while probe != None and target_item != probe.data:
    probe = probe.next

if probe != None:
    print(f'Target item {target_item} has been found')
else:
    print(f'Target it

Target item 2 has been found

# * Remplazo de un elemento
probe = head
target_item = 3
new_item = "Z"

while probe != None and target_item != probe.data:
    probe = probe.next

if probe != None:
    probe.data = new_item
    print(f"{new_item} replace the old value in the node number {target_item}")
else:
    print(f"The target item {target_item} is not in the linked list")

Z replace the old value in the node number 3

Recorrido de la lista:
5
4
Z
2
1

# * Insertar un nuevo elemento/nodo al inicio(head)
head = Node("F", head)

Recorrido de la lista:
F
5
4
Z
2
1

# * Insertar un nuevo elemento/nodo al final(tail)
new_node = Node("K")
if head is None:
    head = new_node
else:
    probe = head
    while probe.next != None:
        probe = probe.next
    probe.next = new_node

Recorrido de la lista:
F
5
4
Z
2
1
K

# * Eliminar un elmento/nodo al inicio(head)
removed_item = head.data
head = head.next
print("Removed_item: ",end="")
print(removed_item)

Removed_item: F

Recorrido de la lista:
5
4
Z
2
1
K

# * Eliminar un elmento/nodo al final(tail)
removed_item = head.data
if head.next is None:
    head = None
else:
    probe = head
    while probe.next.next != None:
        probe = probe.next
    removed_item = probe.next.data
    probe.next = None

print("Removed_item: ",end="")
print(removed_item)

Removed_item: K

Recorrido de la lista:
5
4
Z
2
1

# * Agregar un nuevo elemento/nodo por "indice" inverso(Cuenta de Head - Tail)
# new_item = input("Enter new item: ")
# index = int(input("Enter the position to insert the new item: "))
new_item = "10"
index = 3

if head is None or index <= 0:
    head = Node(new_item, head)
else:
    probe = head
    while index > 1 and probe.next != None:
        probe = probe.next
        index -= 1
    probe.next = Node(new_item, probe.next)

# * Agregar un nuevo elemento/nodo por "indice" inverso(Cuenta de Head - Tail)

Recorrido de la lista:
5
4
Z
10
2
1

# * Eliminar un nuevo elemento/nodo por "indice" inverso(Cuenta de Head - Tail)
index = 3

if head is None or index <= 0:
    removed_item = head.data
    head = head.next
    print(removed_item)
else:
    probe = head
    while index > 1 and probe.next.next != None:
        probe = probe.next
        index -= 1
    removed_item = probe.next.data
    probe.next = probe.next.next

    print("Removed_item: ",end="")
    print(removed_item)

Removed_item: 10
Recorrido de la lista:
5
4
Z
2
1

¿Y el uso práctico de estos temas? 🤔 Mucho código pero siento un poco a la carrera la explicación de lo que se está haciendo.

Este curso me está volviendo loco. La verdad no me gusta para nada este profesor ni su método de enseñanza. ): Manden ánimos.

Una aclaración.
En el minuto 3:25 la razón por la cual no se imprime la variable de prueba “probe” es porque en la linea anterior se habia asignado a “probe” la referencia de “head” que era =None. (puesto que en el ciclo anterior la ultima referencia de head fue None)
Por lo tanto al referenciar “probe” a None esta no entra al ciclo while.

desde la clase pasada lo que mas menciona es que es complejo y que es complejo, y hasta cierto punto lo es pero si hubiera sido un buena clase, no solo tirar codigo creo ya no fuera tan complejo…

No quiero sonar fanboy. Pero para los que sientan que el problema es que la clase va demasiado rápido.    La respuesta es NO.
 
Leyendo los comentarios he visto y asumo y si me equivoco les pido una disculpa.
 
Pero creo que la mayoría comienza a programar desde lenguajes de medio/alto nivel y están demasiado acostumbrados a usar métodos y no se detienen a pensar en como funcionan los mecanismos internos de esos métodos.
 
Quisiera compartirles un poco de mi historia. yo empecé por aprender python como mi primer lenguaje y me estanque con lo de las lista y diccionarios 😂 no las entendía así que lo deje.
 
Pero después investigando descubrí que python fue hecho en C y decidí aventarme a C por que quería saber como había sido hecho python y me tropecé con los punteros, el quebradero de cabeza que me di 😂 los nodos y el manejo de memoria era el pan de cada día y era difícil y tampoco los entendía del todo y descubrí que había un lenguaje mas abajo de C y era ensamblador
 
(si estoy un poco loco XD) PERO solo cuando toque los fierros de la maquina (sin albur 😂) comprendí como funcionaban las cosas, entendí mejor a C y al entender a C ahora que estoy con python entiendo mucho mas cosas de python que si solo me hubiera quedado aprendiendo implementaciones y métodos.
 
lo que voy a decir sonara tabu pero si quieren aprender un lenguaje o comprenderlo mejor denle una vuelta a C y a ensamblador no se van ha arrepentir en especial si estan empezando o si ven que los códigos escritos como los que se hicieron en estas clases van muy rápidos o son confusos.
 
les quiero compartir una charla de por que todos los programadores deberían conocer ensamblador impartida por un profesor de la universidad de Alicante.
 
PD: Comencé con Python y termine enamorándome de C y ensamblador 🧡

por andar a las carreras va sacando código con errores, en el método de buscar un item como es posible que genere nodos con valores del 1 al 5, y cuando busca el 2 y le sale que no existe dice que efectivamente no existe xD

soy re fan de platzi pero este curso me esta dando pena…

No mas por aclarar, el item 2 si existe en la linked list, el problema es que cuando lo intentó recorrer usando:

while head != None:
    print(head.data)
    head = head.next

Dejo head apuntando al final de la linked list, por lo al asignar probe = head, probe ya es None y no entra al While

dice que usemos la terminal para que fuera mas claro todo pero en mi caso fue la peor idea, no entendi nada y tuve que ver el video varias veces y pausarlo ,hubiera sido mejor hacer un script y comentar linea por linea y analizarla o usar la herramienta de debuggin para ver que hace el codigo ya que la idea era ver como se ejecuta el codigo en terminal en tiempo real pero no se logro el objetivo por que en la mayoria de los ejemplos no se muestra que es lo que esta pasando y se vuelve mas confuso a mi parecer

siento que este tema es para darlo mas lento y extendido, por mi parte ya me compre otro curso y voy a practicar lo básico en hackerrank

definitivamente es otra pesima clase , y no se trata de ir y averiguar o consultar otras fuentes para entender o profundizar en el tema, el profesor Hector , se pone hacer solito el codigo y no explica cual va ser el objetivo y toca estar tratando de adivinar y a parte no explica . Las estructura de datos se deberian explicar a modo gráfico antes de ir a código. Ya toco ir a ver el curso de estructura de datos de codigo facilito.

Otra clase mal explicada, al crear la lista inicial no hace nada ya que al final head le queda en None, de ahí para allá como no tiene una lista de nodos NO PRUEBA NADA, con mucho respeto creo que el profe no organizó bien su clase o tiene falla en los conceptos que intenta explicar, la clase anterior su puntero “tail” era la cabeza y en esta clase también hay algunas fallas en su código como por ejemplo cuando hace la funcionalidad para “removed_item”, lo quita junto con todo lo que hay después de ese item.
Al comienzo (minuto 3:07) cuando declara la variable “probe”, ahí debía imprimir la lista, al ser un puntero temporal puedo recorrer la lista sin perder su información pero no imprime nada, por que? porque cuando imprimió usando el puntero “head” la perdió, no tiene ningún sentido recorrer una lista para perderla, en fin, pésima clase.

Solo quería recomendar que para este tipo de explicaciones sería mejor utilizar Notebook de Jupyter o DeepNote, se los recomiendo porque es mas práctico.

Comparto un video que me aclaró los conceptos

https://www.youtube.com/watch?v=FSsriWQ0qYE

El profesor es bueno para ilustrar y aclarar conceptos, sin embargo, siento que por el afán de explicar y echar código como si ya fuerámos expertos y entendiéramos a la primera, se pierde el interés en el curso y nos obliga a buscar otras fuentes. Aclaro, siempre hay que buscar otras fuentes además de estás clases pero por primera vez me está tocando ir primero a fuentes externas para luego venir acá y entender poco a poco lo que explica el profesor. Para mi Platzi se ha caracterizado por ayudar a entender conceptos básicos o complejos de forma preliminar de una forma muy sencilla, pero siento que este curso está siendo todo lo contrario. Espero lo puedan mejorar a futuro.

¿cómo me vas a decir hector en el minuto 5:06 que el elemento 2 no está en la lista si la lista son los números del 1 al 5?
¡Esto pasa porque realmente no estamos haciendo ningún recorrido en el ciclo while! ¡la variable probe entra siendo None desde antes de iniciar las iteraciones cuando decimos probe = head! No entiendo como puede el profesor estar tan tranquilo con un error de estos que lo confunden tanto a uno como estudiante. Si me estoy equivocando agradecería que alguien me lo dijera

Mucho código y poca explicación.

la metodologia para explicar es equivocada y utilizar el terminal para explicar aun peor.

Aquí explicaciones y ejemplos sobre Linked Lists:
https://www.geeksforgeeks.org/data-structures/linked-list/?ref=lbp

Podrías usar un .ipynb y así se podría contar con una documentación. Recordá que es una clase no un demo en vivo.

No entendí nada 🥲

Antes de hacer hate, miren el video que sigue. Imposible pues si no queda muy claro el tema. :3

La verdad el curso esta o muy mal explicado o muy mal ubicado en la ruta de aprendizaje, no entiendo el objetivo del curso, no veo como aplicarlo en un proyecto.

Un curso que debe mejorar

creo que hay elementos que deberían ser explicados de una forma más visual para facilitar la comprensión, ya que imaginar el código simultáneamente a la velocidad del vídeo resulta un poco asfixiante

Esta es la única clase de platzi que no me ha gustado y aparte que no entiendo. El profesor no explica a detalle lo que esta haciendo y no es un tema muy difícil pues investigue por mi cuenta y le entendí rápidamente

Forma de implementación de SinglyList:

from node import Node

class SinglyListSingle:

    POSITION = 1
    DATA = 2

    def __init__(self, node = None):
        self.__node = node

    def load_node(self, init, end):
        node = None
        for count in range(init, end):
            node = Node(count, node)
        self.__node = node

    def __str__(self):
        probe = self.__node
        ret = ""
        if not probe is None:
            position = 1
            while not probe is None:
                ret += f'Posición {position} dato {probe.data}\n\r'
                position += 1
                probe = probe.next
        return ret

    #Agregamos nodos en cualquier posición permitida
    def add(self, position, node):
        if self.__node is None:
            self.__node = node
        elif position <= 0:
            #Se registra al principio
            node.next = self.__node
            self.__node = node
        else:
            try:
                #Obtenemos el nodo en la posición previa a donde insertar
                find_previous_node_position = self.__find_by_position(position - 1)
                assert not find_previous_node_position is None, f'The position {position} is not allowed'
                #Al nuevo nodo le agregamos el siguiente nodo del nodo encontrado, si tiene dato, es decir, no es el último
                node.next = find_previous_node_position.next.next if find_previous_node_position.next != None else None
                #El nodo encontrado, en la posición siguiente, le agregamos el nodo
                find_previous_node_position.next = node
            except AssertionError as ae:
                print(ae)

    def __find_by_position(self, position):
        node_ret = self.__node
        item = 1
        while node_ret != None and item != position:
            node_ret = node_ret.next
            item += 1

        return node_ret

    def __find_by_data(self, data):
        node_ret = self.__node
        while node_ret != None and node_ret.data != data:
            node_ret = node_ret.next
        return node_ret

    def __find_position_by_data(self, data):
        position_ret = 1
        node = self.__node
        while node != None and node.data != data:
            position_ret += 1
            node = node.next
        return position_ret

    def update(self, by, search, data):
        try:
            assert by in (self.POSITION, self.DATA), f'{by} no es un tipo de dato mi_singlylistlinked_simple.mi_singlylistlinked_simple_by'
            if by == self.POSITION:
                node = self.__find_by_position(search)
            if by == self.DATA:
                node = self.__find_by_data(search)
            assert not node is None, f'The node {search} not found'
            node.data = data
        except AssertionError as ae:
            print(ae)


    def remove(self, by, search):
        try:
            assert by in (self.POSITION, self.DATA), f'{by} no es un tipo de dato mi_singlylistlinked_simple.mi_singlylistlinked_simple_by'
            if by == self.POSITION:
                #Si es el primer nodo
                if search == 1:
                    #Movemos una posición
                    self.__node = self.__node.next
                    return True
                #Buscamos el nodo en la posición
                node = self.__find_by_position(search - 1)
            if by == self.DATA:
                #Obtenemos la posición del dato del nodo y llamamos a la misma función
                return self.remove(self.POSITION, self.__find_position_by_data(search))

            assert not node is None, f'The node {search} not found'
            node.next = node.next.next
            return True
        except AssertionError as ae:
            print(ae)
            return False
    

Uso:

from mi_singlylistlinked_simple import SinglyListSingle
from node import Node

def run():
    linked_list = SinglyListSingle()
    linked_list.load_node(1, 6)
    print(linked_list)
    linked_list.add(3, Node('W'))
    print(linked_list)
    linked_list.add(6, Node('Z'))
    print(linked_list)
    linked_list.add(9, Node('CX'))
    print(linked_list)
    linked_list.update(SinglyListSingle.POSITION, 5, 'Actualizar')
    print(linked_list)
    linked_list.update(SinglyListSingle.DATA, 'Actualizar', 'Nuevamente actualziado')
    print(linked_list)

if __name__ == '__main__':
    run()

El Código para reemplazo

from node import Node
def replace():
    head = None
    for count in range(1,6):
        head = Node(count,head)

    probe = head # puntero temporal para explorar nodos
    target_item = 3
    new_item = "Z"

    while probe != None and target_item != probe.data:
        probe = probe.next

    if probe != None:
        print(f"{new_item} replaced the old value in the node number {target_item}")

    else:
        print(f"the target item {target_item} is not in the linked list")

if __name__ == '__main__':
    replace()

El codigo si encuentra a 3 y lo reemplaza con “Z”

Les comparto la clase con todas las operaciones antes vistas y algunas más:

Single Linked List explained in YT

me da pena ver como el código le falla, y el profe no hace nada, ¿Cómo no va a ser encontrado el nodo que tiene el valor “2”? si la lista va del 1 al 5, tiene que existir el nodo 2, lo mismo cuando reemplaza el item 3, no lo encuentra, pero cómo deja pasar esos dos errores y el problema esta en probe = head, dado que head vale None, jamás entra en los while y no recorre la lista.
Creo que le profe debío haber importado linked_list en vez de node

Gracias por los métodos para decirle a Bing que me explique 🤣 porque el profe no quiso.

Sumando al comentario de no quiero parecer fan boy, pero si toca leer muchachxs este articulo les dara mayor comprension https://realpython.com/linked-lists-python/, la clase de hector es buena

Insertar al principio de la lista:

Crea un nuevo nodo con el dato deseado.

• Establece el enlace nextdel nuevo nodo para que apunte al nodo actual de la cabeza.
  Actualiza la cabeza de la lista para que apunte al nuevo nodo.
  Insertar al final de la lista:

Crea un nuevo nodo con el dato deseado.

• Recorre la lista hasta llegar al último nodo.
  Establece el enlace nextdel último nodo para que apunte al nuevo nodo.
  Insertar en una posición específica:

Crea un nuevo nodo con el dato deseado.

Recorre la lista hasta llegar a la posición deseada.
Establece el enlace nextdel nuevo nodo para que apunte al siguiente nodo.
Actualiza el enlace nextdel nodo anterior para que apunte al nuevo nodo.

Eliminar un nodo:

Recorre la lista hasta encontrar el nodo a eliminar.

• Actualiza el enlace nextdel nodo anterior para que apunte al siguiente nodo, omitiendo el nodo a eliminar.
  Libera la memoria del nudo eliminado.
  Buscar un elemento:

Recorre la lista comparando el

• Si el elemento se encuentra, devuelve el nodo correspondiente.
  Si se llega al final de la lista sin encontrar el elemento, devuelve un valor indicando que no se encontró.
  Obtener la longitud de la lista:

Recorre la lista contando la cantidad de nodos encontrados.

• Devuelve el número de nodos contados.
  Es importante tener en cuenta que estas operaciones están basadas en una lista enlazada simple, donde solo se tiene acceso a la cabeza de la lista y cada nodo solo contiene una referencia al siguiente nodo. Si se requieren operaciones lógicas más complejas, como inserción o eliminación en posiciones específicas, puede ser necesario implementar adicional para buscar y manipular

Recuerda que al trabajar con una lista enlazada simple, debes actualizar correctamente los enlaces nextpara mantener la coherencia de la lista.

Recomiendo el siguiente vídeo para poder entender : https://youtu.be/oXuKUkIlv_o

Para este caso todos los nodos tienen como next value “None”, por lo que el la operacion de añadir se queda en un loop. De igual manera si se aplica a una single linked list, este deberia funcionar sin problema.

Comunidad les comparto como me quedó la clase SinglyLinkedList

from node import Node

class SinglyLinkedList:
  def __init__(self):
    self.head = None
    self.size = 0

  def append(self, data):
    node = Node(data)

    if self.head == None:
      self.head = node
    else:
      current = self.head

      while current.next:
        current = current.next

      current.next = node
    
    self.size += 1

  """
  Imprime los datos de la singly linked list
  """
  def print_items(self):
    for node in self.iter():
      print(str(node))

  """
    Retorna el tamaño de la lista
  """
  def size(self):
    return str(self.size)

  """
    Nos devuelve el iterador de la lista
  """
  def iter(self):
    current = self.head
    while current:
      val = current.data
      current = current.next
      yield val

  """
    Busca un dato dentro de lista
  """
  def search(self, data):
    flag = False
    for node in self.iter():
      flag = True if data == node else False
    print(f"Data {data} has been founded") if flag else print(f"Data {data} is not in the linked list")

  """
    Reemplaza un dato de la lista
  """
  def replace(self, target_item, data):
    current = self.head
    while current:
      if current.data == target_item:
        current.data = data
        print(f"{data} repalced the old value in the node number {target_item}")
        break
      else:
        current = current.next
  
  """
    Añade un nodo en la cabeza de la lista
  """
  def add_head(self, data):
    self.head = Node(data, self.head)
    self.size += 1

  """
    Elimina un nodo en la cabeza de la lista
  """
  def delete_head(self):
    self.head = self.head.next
    self.size -= 1
  
  """
    Elimina un nodo en la cola de la lista
  """
  def delete_tail(self):
    if self.head.next is None:
      self.head = None
    else:
      current = self.head
      while current.next.next != None:
        current = current.next
      current.next = None
    self.size -= 1
  
  """
    Añade un elemento en un indice dado
  """
  def add_on_index(self, data, index):
    if self.head is None or index < 0:
      self.head = Node(data, self.head)
      self.size += 1
    else:
      current = self.head
      while index > 1 and current.next != None:
        current = current.next
        index -= 1
      current.next = Node(data, current.next)
      self.size += 1
  
  """
    Elimina un elemento en un indice dado
  """
  def delete_on_index(self, index):
    if self.head.next is None or index <= 0:
      self.head = self.head.next
      self.size -= 1
    else:
      current = self.head
      while index > 1 and current.next.next != None:
        current = current.next
        index -= 1
      current.next = current.next.next
      self.size -= 1

  def clear(self):
    self.head = None
    self.head = None
    self.size = 0

Hola, de esta manera me quedo la clase SinglyLinkedList

from node import Node

class SinglyLinkedList:

    def __init__(self):
        self.tail = None
        self.size = 0

    def append(self, data):
        node = Node(data)

        if self.tail == None:
            self.tail = node
        else:
            current = self.tail

            while current.next:
                current = current.next
            
            current.next = node

        self.size +=1

    def size(self):
        return str(self.size)

    def iter(self):
        current = self.tail

        while current:
            val = current.data
            current = current.next
            yield val

    def delete(self, data):
        current = self.tail
        previous = self.tail

        while current:
            if current.data == data:
                self.tail = current.next
            else:
                previous.next = current.next
                self.size -= 1
                return current.data

            previous = current
            current = current.next

    def search(self, data):
        for node in self.iter():
            if data == node:
                print(f"Data {data} found!")
            else:
                print(f"This element {data} is not found.")

    def clear(self):
        self.tail = None
        self.head = None
        self.size = 0

    def printList(self):
        print("\n Esta es la lista:")
        for node in self.iter():
            print(node)


    def replace(self, data, position):
        current = self.tail
        pos=0
        while current:
            if pos == position:
                current.data = data
            else:
                current = current.next
            pos+=1


    def insertHead(self, data):
        self.tail = Node(data, self.tail)


    def removeHead(self):
        current= self.tail
        self.tail = current.next


    def removeTail(self):
        tam = self.size
        elem = self.tail
        for i in range(tam):
            if i == tam-1:
                elem.next = None
            else:
                elem = elem.next


    def insertPosition(self, data, position):
        elem = self.tail
        for i in range(1, self.size):
            if position-1 == i:
                after = Node(data, elem.next)
                elem.next = after
            else: 
                elem = elem.next

Primera parte del codigo queda de esta manera.
No veo la necesidad de usar python en la terminal para este ejemplo.

from node import Node
def run():
    head = None
    for count in range(1,6):
        head = Node(count,head)
    probe = head # puntero temporal para explorar nodos
    target_item = 2
    while probe != None and target_item != probe.data:
        probe = probe.next

    if probe != None:
        print(f"Target item {target_item} has been found")

    else:
        print(f"Target item {target_item} is not in the linked list")

if __name__ == '__main__':
    run()

Para los que se están quemando las pestañas por no saber porqué cuando se busca un elemento no se encuentra, recuerden que al principio se asigno la variable head = None, esto hace que al llamar probe=head en la busqueda nunca entre al ciclo while ya que esta vacía. vuelvan a llamar el loop de For del principio para que les cargue el singly linked list y poder buscar el elemento. Así:

#Busqueda de un Elemento
    for count in range(1,6):
        head = Node(count,head)
    probe = head
    target_item = 3
    while probe != None and target_item != probe.data:
        print(f'Target_item: {target_item} Probe.data: {probe.data}')
        probe = probe.next
    if probe != None:
        print(f'Target item {target_item} has been found')
    else:
        print(f'Target item {target_item} is not in the list')

Salida

Target item 3 has been found

Aquellos que todavía tienen dudas les recomiendo ver este video, me ayudó mucho a entender mejor: https://www.youtube.com/watch?v=qp8u-frRAnU

Desde el minuto 3:25 hasta el 7:23 el profesor comete una serie de fallas debido a un bucle while que deja a head = None, en lugar de ser igual a 5. Me sorprende que al pasar tanto tiempo no se haya preguntado por un segundo que es lo que andaba mal en su codigo que todo salia de una forma la cual no esperaba. En lugar de esto justifica los errores con cosas sin sentido.

Esto es lo que esperaba que aparecería en pantalla ya que el 2 si está en la linked list y probe funciona exactamente igual que el head

Luego el sig ejercicio donde busca el 3 e intenta crear un nuevo nodo con la data = “K” tambien se comete el mismo error de raiz.

Este ha sido un muy buen curso, pero esta clase solo es ver código sin entender del todo que hace, o para que me puede servir.

¿Este video no es redundante?

2.- Reemplazo de un elemento por indice

jeje yo ya había implementado casi todas esa funciones en mi propia clase NODO en la clase pasada. Pero no se me había ocurrido hacer un método de agregado de clase NODO por índice asta que vi el ejemplo que propuso el profe XD toca implementarla XD

Estos fueron los métodos que cree a partir de esta clase:

    def set_new_item(self, item, index):
        """Set a new item in the list on a specific position"""

        current = self.head
        previous = None
        for i in range(index):
            previous = current
            current = current.next
        if previous is None:
            self.head = Node(item)
            self.head.next = current
        else:
            previous.next = Node(item)
            previous.next.next = current
        self.size += 1

    def remove_a_specific_item(self, index):
        """Remove a specific item from the list"""

        current = self.head
        previous = None
        for i in range(index):
            previous = current
            current = current.next
        if previous is None: self.head = current.next
        else: previous.next = current.next
        self.size -= 1