遍历上题单链表，显示全部结点数据

好的，我可以帮你编写一个遍历单链表并显示全部结点数据的程序示例。以下是示例代码：

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

# 创建示例单链表
head = ListNode(1)
node1 = ListNode(2)
node2 = ListNode(3)
node3 = ListNode(4)
head.next = node1
node1.next = node2
node2.next = node3

# 遍历单链表并显示结点数据
current = head
while current:
    print(current.val)
    current = current.next

在上面的示例代码中，我们首先定义了一个单链表结点类 `ListNode`，然后创建了一个示例单链表 `head`，并将其各结点的 `val` 值分别设置为 1、2、3、4。

接着，我们使用一个 `while` 循环遍历单链表，并在每次遍历时输出当前结点的 `val` 值。在循环体内，我们首先输出当前结点的 `val` 值，然后将 `current` 指针指向下一个结点，以便在下一次循环中继续输出下一个结点的数据，直到遍历完整个单链表为止。

你可以根据自己的实际需要，修改上面示例代码中的单链表数据，以及输出方式等，来满足你的具体需求。

相关问题

定义单链表的类，实现一个带定义单链表的类，实现一个带头结点的单链表的逆置，并将逆置前后的单链表分别遍历输出。单链表中各结点的值和结点个数等自定。 头结点的单链表的逆置，并将逆置前后的单链表分别遍历输出。单链表中各结点的值和结点个数等自定。

首先，我们可以定义一个`ListNode`类，代表单链表中的节点，包含一个数据元素和指向下一个节点的指针：

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

# 创建一个带头结点的单链表类
class DoublyLinkedList:
    def __init__(self):
        self.head = ListNode(0)  # 初始化头结点
        self.tail = self.head  # 尾部默认指向头结点
        self.length = 0  # 存储链表长度

    # 添加节点到链表尾部
    def append(self, data):
        new_node = ListNode(data)
        self.tail.next = new_node
        self.tail = new_node
        self.length += 1

    # 逆置链表
    def reverse(self):
        prev = None
        current = self.head
        while current:
            next_temp = current.next  # 临时保存当前节点的下一个节点
            current.next = prev  # 转换方向，让当前节点指向前一个节点
            prev = current  # 更新前驱节点
            current = next_temp  # 移动到下一个节点
        self.tail = self.head  # 新的头结点变为原来的尾结点

    # 遍历并打印链表
    def traverse(self):
        current = self.head
        while current:
            print(current.val, end=" -> ")
            current = current.next
        print("None")

    # 遍历逆置后的链表
    def traverse_reversed(self):
        current = self.tail
        while current is not None:
            print(current.val, end=" -> ")
            current = current.next
        print("None")

在这个`DoublyLinkedList`类中，我们实现了链表的基本操作（添加节点、逆置链表以及遍历），你可以根据需要创建链表实例并测试逆置功能。

c++定义单链表的类，实现一个带头结点的单链表的逆置，并将逆置前后的单链表分别遍历输出。单链表中各结点的值和结点个数等自定。

在C++中，我们可以定义一个`Node`类表示链表节点，包含一个数据成员和指向下一个节点的指针。然后定义一个`SingleLinkedList`类，其中包含头节点、插入节点的功能以及链表的反转操作。下面是一个简单的实现：

#include <iostream>

// 定义链表节点
class Node {
public:
    int data;
    Node* next;

    Node(int val) : data(val), next(nullptr) {}
};

// 单链表类
class SingleLinkedList {
private:
    Node* head;  // 头节点

public:
    SingleLinkedList() : head(nullptr) {}

    // 插入节点到链表尾部
    void insert(int value) {
        if (!head) {
            head = new Node(value);
        } else {
            Node* current = head;
            while (current->next) {
                current = current->next;
            }
            current->next = new Node(value);
        }
    }

    // 链表反转
    void reverse() {
        Node* prev = nullptr;
        Node* current = head;
        Node* nextTemp;

        while (current) {
            nextTemp = current->next;
            current->next = prev;
            prev = current;
            current = nextTemp;
        }
        head = prev;
    }

    // 遍历并打印链表
    void printList() {
        Node* temp = head;
        while (temp) {
            std::cout << temp->data << " ";
            temp = temp->next;
        }
        std::cout << "\n";
    }

    // 打印反转后的链表
    void printReversedList() {
        Node* temp = head;
        while (temp) {
            std::cout << temp->data << " ";
            temp = temp->next;
        }
        std::cout << "\nReversed: ";
        temp = head;
        while (temp) {
            std::cout << temp->data << " ";
            temp = temp->next;
        }
        std::cout << "\n";
    }
};

现在你可以创建一个`SingleLinkedList`实例，插入一些节点，然后反转链表并打印原始链表和反转后的链表。