输出带头结点单链表的所有结点元素值

对于带头结点的单链表，头结点不存储任何元素值，因此只需要遍历头结点的后继结点，输出其元素值即可。代码如下：

def print_linked_list(head):
    p = head.next   # p指向头结点的后继结点
    while p:
        print(p.data)
        p = p.next

其中，`head.next`表示头结点的后继结点，`p = head.next`将p指向头结点的后继结点，`while p:`表示在p不为空的情况下循环，每次循环输出p的元素值，并将p指向下一个结点，即`p = p.next`。

相关问题

输出带头结点单链表的函数

以下是带头结点单链表的函数实现：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node, *LinkedList;

LinkedList createLinkedList() {
    LinkedList L = (LinkedList)malloc(sizeof(Node));
    L->next = NULL;
    return L;
}

void insert(LinkedList L, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = L->next;
    L->next = newNode;
}

void delete(LinkedList L, int data) {
    Node* p = L->next;
    Node* pre = L;
    while (p != NULL) {
        if (p->data == data) {
            pre->next = p->next;
            free(p);
            return;
        }
        pre = p;
        p = p->next;
    }
}

void display(LinkedList L) {
    Node* p = L->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

void destroy(LinkedList L) {
    Node* p = L->next;
    while (p != NULL) {
        Node* next = p->next;
        free(p);
        p = next;
    }
    free(L);
}

int main() {
    LinkedList L = createLinkedList();
    insert(L, 1);
    insert(L, 2);
    insert(L, 3);
    display(L);
    delete(L, 2);
    display(L);
    destroy(L);
    return 0;
}

设计一个算法，将一个结点值为自然数的带头结点单链表拆分为两个带头结点单链表，原表中保留值为偶数的结点，而值为奇数的结点按它们在原表中的相对次序组成一个新的带头结点单链表。

算法如下：

1. 定义两个新的带头结点单链表，分别为evenList和oddList。

2. 遍历原链表，如果结点的值为偶数，则将该结点插入evenList中；如果结点的值为奇数，则将该结点插入oddList中。

3. 遍历完原链表后，将oddList插入到evenList的末尾。

4. 返回evenList和oddList。

代码实现如下：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

pair<ListNode*, ListNode*> splitList(ListNode* head) {
    ListNode* evenList = new ListNode(0);
    ListNode* oddList = new ListNode(0);
    ListNode* evenTail = evenList;
    ListNode* oddTail = oddList;
    ListNode* cur = head->next;
    while (cur != NULL) {
        if (cur->val % 2 == 0) {
            evenTail->next = cur;
            evenTail = evenTail->next;
        } else {
            oddTail->next = cur;
            oddTail = oddTail->next;
        }
        cur = cur->next;
    }
    evenTail->next = oddList->next;
    oddTail->next = NULL;
    return make_pair(evenList, oddList);
}