Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Crear nodos

10/23
Recursos

Aportes 11

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Y con esto queda claro como funciona una queue o un stack 😮

Hasta ahora, que curso tan bueno 😄

Resumen:
■■■■■■■

Crear Nodos.

Cada nodo almacenará un valor y cada nodo tiene un puntero que llevará a otro nodo con otro valor y así obtener los datos allí almacenados.
Es muy útil al tener infromación dispersa en memoria y cuando queremos que sean consultas ágiles, es importante entender que los nodos son la base para implementaciones más elaboradas de estructuras de datos, Stacks, Qeues, Deque, Doubly, Singly List, Circular list, Graphs .


Cada estructura de datos servirá para un propósito dentro de un contexto, por ejemplo los grafos acíclicos, donde se usan para sistemas de recomendaciones al mostrar las relaciones entre objetos o representar los tipos de redes que se forman entre nodos. Para crear un nodo:

  • Creamos una clase Node
  • Referimos valores mediante argumentos de instancias.
  • Unimos los nodos iterando entre referencias.

Este script tiene como propósito crear nodos.

Constructor:

  • data= El dato del nodo.
  • next= está por defecto en None, porque en una serie de nodos el +ultimo te lleva a ninguna parte
class Node():
    def __init__(self, data, _next=None):
        # Atributos
        self.data = data
        self.next = _next

A continuación la instancia de la clase Node



from node import Node


node1 = None
node2 = Node("A", None)
# Los nodos al ser secuanciales permiten refrencias a cualquier lugar.
node3 = Node("B", node2)



def show_relations():
    '''
    Este script perfectamente puede ser una función que recibe al nodo como parámetro pythony llamo para mostrar las
    relaciones.

    '''
    print("Esto es la ubicación en memoria de los nodos")
    print(node2) #<node.Node object at 0x0000022017FEAD30>
    print(node3) #<node.Node object at 0x0000022017FEAD90>
    print("Esto es el dato y muestra la relación entre nodos")
    print(node2.data,"-->", node2.next) #A --> None
    print(node3.data,"-->", node3.next) #B --> <node.Node object at 0x0000015356D6AD30>
    print("El siguiente dato del nodo es:")
    # Se refiere al nodo que está conectado y luego al dato que este contiene.
    print(node3.next.data) #'A'
    print("Creando el nodo1 y mostrando datos y relacion con nodo3 obtenemos: ")
    # Asignar una propiedad a un elemento para volverlo nodo.
    # Al intanciar la clase con una relación estamos ligando los nodos.
    node1= Node("C", node3)
    print(node1.data,"-->", node1.next)#C --> <node.Node object at 0x0000022017FEAD90>



def create_nodes():
    print("Creo nodos que se asignan a un solo valor en memoria, en este caso a node2: ")
    for node in range(5): #n --> <node.Node object at 0x000001B2AD991FD0>
        head = Node(node, node2)
        print(head.data,"-->", head.next)


def run():
    show_relations()
    create_nodes()

if __name__ == '__main__':
    run()

Pienso que el for debio haber sido
for count in range(1,6)
para que coincida con la deapositiva de crear 5 nodos.
Recuerden que en la función range, el segundo valor es exclusivo, por lo que no es agregado.


Aún me parece extraño que aunque se sobreescriba la variable head para crear otro nodo, esta siga guardando la referencia en memoria del anterior nodo creado.

Una forma mas clara de ver la composicion de los nodos es usando dataclasses, que son una forma un poco mas sencilla de declarar clases en Python :
Data Classes in Python 3.7+ (Guide)

Clase Node:

Main:

Output:

Sobre todo en el video anterior y al comienzo de este siento que me distrae mucho, mientras explica datos importantes, cuando mira hacia arriba o a su derecha (si es un telepronter o la pantalla) genial que a futuro actualicen estas clases que están muy interesantes ubicando la pantalla justo en frente o de algún ángulo que no se note tanto el cambio de vista. Gracias.

Aqui implemento las clases creadas

Siendo un poco explícito, hicimos algo así:

woooo, esto es muy nuevo, esta genial

De esta manera dejé mi clase de Nodo con tipado estático para que fuese más claro.

from __future__ import annotations
from typing import Any


class Node():
    def __init__(self, data:Any, next: Node = None) -> None:
        self.data = data
        self.next = next

Me encanta como explica al final de la clase que fue lo que se hizo y lo represente en imágenes, así podemos ver con mas claridad que es lo que esta pasando en código.

Yo me Encontre este Aporte en esta Pagina [link](https://programacionycacharreo.wordpress.com/2018/10/05/lista-enlazada-lineal-singly-linked-list-implementacion-en-python/#:~:text=Una lista enlazada (linked list,simple (singly linked list). “link”)

Lista enlazada lineal simple (singly linked list) – Implementación en Python

Una lista enlazada (linked list en inglés), es un tipo de estructura de datos compuesta de nodos.
Cada nodo contiene los datos de ese nodo y enlaces a otros nodos.

Se pueden implementar distintos tipos de listas enlazadas. En este post vamos a implementar una lista
enlazada lineal simple (singly linked list). En este tipo de listas, cada nodo contiene sus datos y un
enlace al siguiente nodo. Además la lista tendrá un método para contar el número de elementos de la lista,
un método para insertar un elemento en la lista y un método para eliminar un elemento de la lista.

En primer lugar, definimos una clase que va a ser la clase Node. Los objetos de esta contendrán sus propios
datos y un enlace al siguiente elemento de la lista:

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

A continuación definimos la clase de la lista SinglyLinkedList, que contiene el primer elemento de la lista:

class SinglyLinkedList:
		def __init__(self, head):
    		self.head = head

El método que cuenta los elementos de la lista, length(), primero comprueba que la lista no esté vacía, y luego
recorre todos los elementos de la lista incrementando un contador por cada elemento. Al final devuelve el contador:

 def length(self):
    	current = self.head
    	if current is not None:
        		count = 1

        		while current.next is not None:
            		count += 1
            		current = current.next
        		return count
    	else:
        		return 0

El siguiente método, insert(datos, posición), inserta un elemento tras la posición indicada. Si se indica la posición 0,
el nuevo elemento pasa a ser la cabecera de la lista. En esta implementación, si la posición que se pasa como argumento
excede el tamaño de la lista, el elemento se inserta al final:

    def insert(self, data, position):
    	new_node = Node(data)

    	if position == 0:
        		new_node.next = linked_list.head
        		linked_list.head = new_node
    	else:
        		current = linked_list.head
        		k = 1
        		while current.next is not None and k < position:
            		current = current.next
            		k += 1
        		new_node.next = current.next
        		current.next = new_node

El método delete(posición) borra el elemento en la posición pasada como parámetro. Si es el primer elemento la lista de la
cabeza pasa a ser el segundo elemento. Si se encuentra el elemento en la lista y se borra devolvemos True, en caso contrario
devolvemos False:

def delete(self, position):
    	if position != 1:
        		current = self.head
        		k = 1
        		while current.next is not None and k < position - 1:
            		current = current.next
            		k += 1
        		if current.next is not None:
            		current.next = current.next.next
            		return True
        		else:
            		return False
    	else:
        		self.head = self.head.next
        		return True

con este código podemos comprobar el funcionamiento de la lista:

creamos la lista
linked_list = SinglyLinkedList(Node(1))

rellenamos la lista
for i in range(2,10):
linked_list.insert(i, i-1)

insertamos un elemento
linked_list.insert(999,3)

eliminamos un elemento
linked_list.delete(6)

#mostramos la lista
current = linked_list.head
while current is not None:
print(current.data)
current = current.next

Dándonos esta salida por la consola:

1
2
3
999
4
6
7
8
9