将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使得A表中含有的全是原表中的奇数，而B表中含有原表中为偶数的元素，且保持相对顺序不变（C语言版）

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

// 定义链表结点
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建新结点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在链表末尾插入结点
void insertNode(Node** head, int data) {
    Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 分解链表
void splitList(Node* head, Node** oddList, Node** evenList) {
    Node* current = head->next;
    Node* oddTail = *oddList;
    Node* evenTail = *evenList;

    while (current != NULL) {
        if (current->data % 2 == 0) {
            if (*evenList == NULL) {
                *evenList = current;
                evenTail = current;
            } else {
                evenTail->next = current;
                evenTail = current;
            }
        } else {
            if (*oddList == NULL) {
                *oddList = current;
                oddTail = current;
            } else {
                oddTail->next = current;
                oddTail = current;
            }
        }
        current = current->next;
    }

    if (oddTail != NULL) {
        oddTail->next = NULL;
    }
    if (evenTail != NULL) {
        evenTail->next = NULL;
    }
}

// 打印链表
void printList(Node* head) {
    Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 释放链表内存
void freeList(Node* head) {
    Node* current = head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
}

int main() {
    // 创建原链表A
    Node* A = createNode(-1); // 带头结点
    insertNode(&A, 1);
    insertNode(&A, 2);
    insertNode(&A, 3);
    insertNode(&A, 4);
    insertNode(&A, 5);

    // 创建空链表B和C
    Node* B = createNode(-1); // 带头结点
    Node* C = createNode(-1); // 带头结点

    // 分解链表A
    splitList(A, &B, &C);

    // 打印链表A和B
    printf("链表A中的奇数：");
    printList(A);
    printf("链表B中的偶数：");
    printList(B);

    // 释放链表内存
    freeList(A);
    freeList(B);

    return 0;
}

这个算法中，我们使用了三个指针：current用于遍历原链表A，oddTail用于记录奇数链表A的尾结点，evenTail用于记录偶数链表B的尾结点。我们遍历原链表A的每个结点，根据结点的值判断是奇数还是偶数，然后将结点插入到相应的链表中。最后，我们将奇数链表A的尾结点和偶数链表B的尾结点的next指针置为NULL，以表示链表的结束。

【注意】这个算法假设原链表A的头结点不存储有效数据，而是用作链表的头部标记。因此，在创建链表和打印链表时，我们需要跳过头结点。