python 定义链表

在Python中，可以使用类来定义链表。下面是一个简单的链表节点类的示例：

class ListNode:
    def __init__(self, value):
        self.value = value
        self.next = None

上面的代码定义了一个名为ListNode的类，它有两个属性：value用于存储节点的值，next用于指向下一个节点。通过将next设置为None，可以表示链表的末尾。

要创建一个链表，可以实例化多个ListNode对象，并使用next属性将它们连接起来。例如，以下代码创建了一个包含三个节点的链表：

# 创建节点
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)

# 连接节点
node1.next = node2
node2.next = node3

这样就创建了一个包含值为1、2、3的链表。你可以根据需要添加更多节点或修改节点的值。

相关问题

Python单向链表

Python单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表中的节点按照顺序连接在一起，形成一个链式结构。

下面是Python单向链表的基本实现方式：

1. 定义节点类：首先定义一个节点类，包含两个属性：数据元素和指向下一个节点的指针。

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

2. 定义链表类：链表类包含若干个节点，以及对链表进行操作的方法。

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

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node

    def insert(self, data, position):
        new_node = Node(data)
        if position == 0:
            new_node.next = self.head
            self.head = new_node
        else:
            current = self.head
            for _ in range(position - 1):
                if current.next is None:
                    raise IndexError("Index out of range")
                current = current.next
            new_node.next = current.next
            current.next = new_node

    def delete(self, position):
        if self.head is None:
            raise IndexError("Index out of range")
        if position == 0:
            self.head = self.head.next
        else:
            current = self.head
            for _ in range(position - 1):
                if current.next is None:
                    raise IndexError("Index out of range")
                current = current.next
            if current.next is None:
                raise IndexError("Index out of range")
            current.next = current.next.next

    def get(self, position):
        if self.head is None:
            raise IndexError("Index out of range")
        current = self.head
        for _ in range(position):
            if current.next is None:
                raise IndexError("Index out of range")
            current = current.next
        return current.data

    def size(self):
        count = 0
        current = self.head
        while current:
            count += 1
            current = current.next
        return count

以上是一个简单的Python单向链表的实现，包括了向链表末尾添加节点、在指定位置插入节点、删除指定位置的节点、获取指定位置的节点值以及获取链表长度等基本操作。

python 实现链表

以下是Python实现单链表的示例代码：

# 定义链表节点类
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# 定义链表类
class LinkedList:
    def __init__(self):
        self.head = None

    # 在链表末尾添加节点
    def addAtTail(self, val: int) -> None:
        if not self.head:
            self.head = ListNode(val)
        else:
            cur = self.head
            while cur.next:
                cur = cur.next
            cur.next = ListNode(val)

    # 在链表头部添加节点
    def addAtHead(self, val: int) -> None:
        if not self.head:
            self.head = ListNode(val)
        else:
            new_head = ListNode(val)
            new_head.next = self.head
            self.head = new_head

    # 在指定位置添加节点
    def addAtIndex(self, index: int, val: int) -> None:
        if index == 0:
            self.addAtHead(val)
        else:
            cur = self.head
            for i in range(index - 1):
                if not cur:
                    return
                cur = cur.next
            if not cur:
                return
            new_node = ListNode(val)
            new_node.next = cur.next
            cur.next = new_node

    # 删除指定位置的节点
    def deleteAtIndex(self, index: int) -> None:
        if not self.head:
            return
        if index == 0:
            self.head = self.head.next
        else:
            cur = self.head
            for i in range(index - 1):
                if not cur:
                    return
                cur = cur.next
            if not cur or not cur.next:
                return
            cur.next = cur.next.next

    # 获取指定位置的节点值
    def get(self, index: int) -> int:
        if not self.head:
            return -1
        cur = self.head
        for i in range(index):
            if not cur:
                return -1
            cur = cur.next
        if not cur:
            return -1
        return cur.val

    # 打印链表
    def printList(self) -> None:
        if not self.head:
            print("Empty List")
        else:
            cur = self.head
            while cur:
                print(cur.val, end=" ")
                cur = cur.next
            print()

# 创建链表并测试
linked_list = LinkedList()
linked_list.addAtHead(1)
linked_list.addAtTail(3)
linked_list.addAtIndex(1, 2)
linked_list.printList() # 输出：1 2 3
linked_list.deleteAtIndex(1)
linked_list.printList() # 输出：1 3
print(linked_list.get(1)) # 输出：3