有一个由整数元素构成的非空单链表a，设计一个算法，将其拆分成两个单链表a和b，使得a单链表中含有所有的偶数结点，b单链表中含有所有的奇数结点，且保持原来的相对次序。

### 回答1：
可以使用两个指针分别指向a和b单链表的头结点，遍历原始单链表，将偶数结点插入a单链表，奇数结点插入b单链表。具体实现如下：

1. 初始化a和b单链表的头结点为NULL。

2. 遍历原始单链表，对于每个结点，判断其值是否为偶数。

3. 如果是偶数，将该结点插入a单链表的尾部，更新a的尾指针。

4. 如果是奇数，将该结点插入b单链表的尾部，更新b的尾指针。

5. 遍历完成后，将a单链表的尾指针指向NULL，b单链表的尾指针指向NULL，即可得到拆分后的两个单链表。

代码实现如下：

void splitList(ListNode* head, ListNode*& a, ListNode*& b) {
ListNode* cur = head;
while (cur != NULL) {
if (cur->val % 2 == ) {
// 插入a单链表
if (a == NULL) {
a = cur;
a->next = NULL;
} else {
a->next = cur;
a = a->next;
a->next = NULL;
}
} else {
// 插入b单链表
if (b == NULL) {
b = cur;
b->next = NULL;
} else {
b->next = cur;
b = b->next;
b->next = NULL;
}
}
cur = cur->next;
}
}

### 回答2：
思路：

题目要求我们将一个链表拆分成两个链表，其中一个链表包含偶数结点，另一个链表包含奇数结点，且相对顺序不变。可以想到，我们需要遍历整个链表，将偶数结点和奇数结点分别加入到不同的链表中。在遍历过程中，我们需要记录奇数结点链表和偶数结点链表的尾结点，方便加入新的结点，同时需要保持原来结点的相对次序。

算法步骤：

1. 初始化两个新链表a和b，分别表示偶数结点链表和奇数结点链表。

2. 初始化四个指针p、q、ap和bp，p指向原链表的头结点，q指向p的后继结点，ap指向链表a的尾结点，bp指向链表b的尾结点。

3. 遍历原链表，如果p指向的结点是偶数，就将它加入到链表a中，否则就将它加入到链表b中。

4. 加入结点时，可以利用ap和bp记录链表a和b的尾结点，方便加入新的结点。

5. 遍历结束后，将链表a和b的尾结点置空，表示链表结束。

6. 返回链表a和b。

代码实现：

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

ListNode* splitList(ListNode* head) {
    ListNode *a = NULL, *b = NULL;
    ListNode *p = head, *q = head->next;
    ListNode *ap = NULL, *bp = NULL;
    while (p) {
        if (p->val % 2 == 0) {
            if (!a) {
                a = p;
                ap = p;
            } else {
                ap->next = p;
                ap = ap->next;
            }
        } else {
            if (!b) {
                b = p;
                bp = p;
            } else {
                bp->next = p;
                bp = bp->next;
            }
        }
        p->next = NULL;
        p = q;
        if (q) {
            q = q->next;
        }
    }
    if (ap) {
        ap->next = NULL;
    }
    if (bp) {
        bp->next = NULL;
    }
    return a;
}

时间复杂度为O(n)，空间复杂度为O(1)。

### 回答3：
本题需要使用链表操作和单链表的特点进行解决。具体的做法如下：

1. 定义一个新的单链表b，用于存储原始链表a中的奇数结点；

2. 遍历链表a，对于其中的每个结点，判断当前结点里的数值是否为奇数，若是奇数则将当前结点从链表a中删除，并将其接入链表b的尾部；

3. 最终遍历结束后，链表b中存储的即为所有的奇数结点，链表a中则存储所有的偶数结点。

4. 偶数结点的存储顺序和链表a原来的相对次序一样，但是奇数结点在提取并连接链表b时，因为是从链表a删除并接入b中的，所以并不能保证其存储顺序和a中的相对次序一致。但由于本题只要求a链表中存储的是所有偶数结点，b链表中存储的是所有奇数结点，因此不必考虑相对位置的问题。

5. 将新生成的链表b返回即可。

具体实现代码如下：

ListNode* splitList(ListNode* head) {
    ListNode *odd = nullptr, *even = nullptr, *cur = head, *tail = nullptr;
    while (cur) {
        ListNode *tmp = cur;
        cur = cur->next;
        if (tmp->val % 2 == 0) {
            if (!even) {
                head = tmp;
            } else {
                tail->next = tmp;
            }
            even = tmp;
            even->next = nullptr;
        } else {
            if (!odd) {
                head = cur;
            } else {
                odd->next = tmp;
            }
            odd = tmp;
        }
    }
    if (even) {
        even->next = odd;
    } else {
        head = odd;
    }
    return head;
}