如何输出双向链表实际前驱节点？Python代码prev显示{...}问题

为什么会显示{...}？ #

这是Python处理循环引用的内置机制。你的双向链表中，每个节点的prev指向前一个节点，而前一个节点的next又指向当前节点——比如节点11的prev是节点10，节点10的next是节点11，形成了循环引用。

当Python尝试递归打印字典形式的节点时，发现已经遍历过某个节点，就会用{...}代替该节点的完整内容，避免无限递归导致程序崩溃。

如何输出实际的节点信息？ #

我们可以通过自定义打印逻辑，避开循环引用的递归遍历，只提取我们需要的关键信息。下面提供几种可行的方案：

方案1：自定义链表打印方法

直接遍历链表，逐个打印每个节点的value以及前后节点的value（而非完整节点对象）：

class LinkedList:
    def __init__(self,value):
        self.head = {
            'value':value,
            'next':None,
            'prev':None,
        }
        self.tail = self.head
        self.length = 1
    def append(self, value):
        newnode = {
            'value':value,
            'next':None,
            'prev':None,
        }
        newnode['prev'] = self.tail
        self.tail['next'] = newnode
        self.tail = newnode
        self.length +=1
        return self.head
    
    # 新增自定义打印方法
    def print_nodes(self):
        current_node = self.head
        while current_node:
            # 提取前后节点的value（不存在则显示None）
            prev_val = current_node['prev']['value'] if current_node['prev'] else None
            next_val = current_node['next']['value'] if current_node['next'] else None
            print(f"节点: value={current_node['value']}, prev={prev_val}, next={next_val}")
            current_node = current_node['next']

# 测试
a = LinkedList(10)
a.append(11)
a.append(3)
a.print_nodes()

执行后输出：

节点: value=10, prev=None, next=11
节点: value=11, prev=10, next=3
节点: value=3, prev=11, next=None

方案2：用类实现节点并自定义__repr__

如果想更规范地管理节点，建议用类代替字典实现节点，然后自定义__repr__方法控制打印格式：

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
        self.prev = None
    
    # 自定义节点的打印格式
    def __repr__(self):
        prev_val = self.prev.value if self.prev else None
        next_val = self.next.value if self.next else None
        return f"Node(value={self.value}, prev={prev_val}, next={next_val})"

class LinkedList:
    def __init__(self, value):
        self.head = Node(value)
        self.tail = self.head
        self.length = 1
    
    def append(self, value):
        new_node = Node(value)
        new_node.prev = self.tail
        self.tail.next = new_node
        self.tail = new_node
        self.length +=1
        return self.head

# 测试
a = LinkedList(10)
a.append(11)
a.append(3)

# 遍历打印所有节点
current = a.head
while current:
    print(current)
    current = current.next

执行后输出：

Node(value=10, prev=None, next=11)
Node(value=11, prev=10, next=3)
Node(value=3, prev=11, next=None)

方案3：序列化节点为JSON格式

如果需要结构化输出，可以使用json模块自定义序列化逻辑，只保留必要信息：

import json

def serialize_node(node):
    if node is None:
        return None
    return {
        'value': node['value'],
        'prev': node['prev']['value'] if node['prev'] else None,
        'next': node['next']['value'] if node['next'] else None
    }

def serialize_linked_list(linked_list):
    nodes = []
    current = linked_list.head
    while current:
        nodes.append(serialize_node(current))
        current = current['next']
    return nodes

# 测试
a = LinkedList(10)
a.append(11)
a.append(3)
print(json.dumps(serialize_linked_list(a), indent=2))

执行后输出：

[
  {
    "value": 10,
    "prev": null,
    "next": 11
  },
  {
    "value": 11,
    "prev": 10,
    "next": 3
  },
  {
    "value": 3,
    "prev": 11,
    "next": null
  }
]

内容的提问来源于stack exchange，提问作者user4258696