本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下

：链表结点定义：

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

实现函数：

ListNode* createList(vector<int>& nums); // 将读入的数据存储为单链表
ListNode* oddEvenList(ListNode* head); // 将链表中奇数值的结点重新组成一个新的链表

相关问题

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。

你可以通过以下函数来实现这个功能：

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

ListNode* createList(vector<int>& nums) {
    if (nums.empty()) {
        return NULL;
    }
    ListNode* head = new ListNode(nums[0]);
    ListNode* cur = head;
    for (int i = 1; i < nums.size(); i++) {
        cur->next = new ListNode(nums[i]);
        cur = cur->next;
    }
    return head;
}

ListNode* oddEvenList(ListNode* head) {
    if (head == NULL) {
        return NULL;
    }
    ListNode* oddHead = NULL;
    ListNode* oddTail = NULL;
    ListNode* evenHead = NULL;
    ListNode* evenTail = NULL;
    ListNode* cur = head;
    int cnt = 1;
    while (cur != NULL) {
        if (cnt % 2 == 1) {
            if (!oddHead) {
                oddHead = cur;
                oddTail = cur;
            } else {
                oddTail->next = cur;
                oddTail = oddTail->next;
            }
        } else {
            if (!evenHead) {
                evenHead = cur;
                evenTail = cur;
            } else {
                evenTail->next = cur;
                evenTail = evenTail->next;
            }
        }
        cur = cur->next;
        cnt++;
    }
    if (oddTail) {
        oddTail->next = evenHead;
    }
    if (evenTail) {
        evenTail->next = NULL;
    }
    return oddHead;
}

上面的代码中，createList() 函数可以将读入的数据存储为单链表，oddEvenList() 函数将链表中奇数值的结点重新组成一个新的链表。具体实现是通过两个链表来存储新链表的奇数结点与偶数结点，最后将它们拼接成一个新的链表返回。

本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下：

### 回答1：
本题要求实现两个函数，第一个函数将读入的数据存储为单链表对于第一个函数，需要实现的功能是将读入的数据存储为单链表。可以使用一个结构体来表示链表结点，其中包含两个字段，一个存储结点的数据值，另一个存储指向下一个结点的指针。在读入数据时，可以创建一个新结点，将数据存入该结点，并将该结点添加到链表的末尾。

对于第二个函数，需要实现的功能是将链表中奇数值的结点重新组成一个新的链表。可以遍历原链表，对于每个结点，判断该结点的值是否为奇数。如果是，就将该结点添加到新链表的末尾。最后返回新链表的头结点。

### 回答2：
本题要求实现两个函数，分别是createList和splitOdd。createList函数将读入的数据存储为单链表，splitOdd函数将链表中奇数值的结点重新组成一个新的链表。

首先来看createList函数的实现。我们需要定义一个指向链表头的指针，并将其初始化为NULL，表示链表为空。然后从输入流中读入数据，创建一个新的结点，并将其插入链表的末尾。具体的实现如下：

Node* createList() {
    Node* head = NULL; //链表头指针
    Node* p = NULL; //当前结点指针
    int x;
    while (cin >> x) { //从输入流中读入数据
        Node* node = new Node(x); //创建新结点
        if (head == NULL) { //如果链表为空，则将新结点设为头结点
            head = node;
        } else { //否则将新结点插入链表末尾
            p = head;
            while (p->next != NULL) { //找到链表末尾的结点
                p = p->next;
            }
            p->next = node; //插入新结点
        }
    }
    return head; //返回链表头指针
}

接下来是splitOdd函数的实现。该函数需要创建一个新的链表来存储奇数值结点。首先需要定义两个指针，一个指向原链表头部，一个指向新链表头部，并将其都初始化为NULL。然后遍历原链表，将奇数值的结点插入到新链表中，并删除原链表中的这些结点。具体的实现如下：

Node* splitOdd(Node*& list) {
    Node* newHead = NULL; //新链表头指针
    Node* newTail = NULL; //新链表尾指针
    Node* p = list; //原链表指针
    Node* prev = NULL; //原链表上一个结点的指针
    while (p != NULL) {
        if (p->data % 2 != 0) { //如果结点值为奇数
            Node* node = p; //保存当前结点
            p = p->next; //指向下一个结点
            if (prev == NULL) { //如果当前结点是头结点，则直接将它从原链表中删除
                list = p;
            } else { //否则，将它从原链表中删除
                prev->next = p;
            }
            node->next = NULL; //将当前结点从原链表中断开
            if (newHead == NULL) { //如果新链表为空，则将当前结点设为新链表头结点
                newHead = node;
                newTail = node;
            } else { //否则，将当前结点插入到新链表末尾
                newTail->next = node;
                newTail = node;
            }
        } else { //如果结点值为偶数，则直接往下遍历
            prev = p;
            p = p->next;
        }
    }
    return newHead; //返回新链表头指针
}

最后是主函数的实现。需要调用createList函数读入数据，并打印原链表和新链表。

int main() {
    Node* list = createList(); //创建原链表
    Node* newList = splitOdd(list); //创建新链表
    cout << "原链表：" << endl;
    printList(list); //打印原链表
    cout << "新链表：" << endl;
    printList(newList); //打印新链表
    return 0;
}

完整的代码如下：

### 回答3：
这道题需要实现两个函数，分别是将输入的数据存储到单链表中和将链表中奇数值的结点重新组成一个新的链表。我们可以先定义好链表结点的结构体，包括数据域和指向下一节点的指针域。如下所示：

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

接下来就是实现两个函数的过程了。首先是将输入数据存储到单链表中。我们可以定义一个头结点指向链表的起始位置，然后不断地使用new来动态分配空间，将读入的数据存储到链表中。代码实现如下：

ListNode* createLinkedList() {
ListNode *head = new ListNode(0);
ListNode *cur = head;
int val;
while (cin >> val) {
ListNode *node = new ListNode(val);
cur->next = node;
cur = cur->next;
}
return head->next;
}

接下来是将链表中奇数值的结点重新组成一个新的链表。我们可以定义两个指针，一个用来指向奇数值的结点，另一个用来指向新链表的尾结点，每次将奇数值的结点插入到新链表的尾部，最后返回新链表的头结点即可。代码实现如下：

ListNode* oddNodes(ListNode* head) {
ListNode *oldcur = head;
ListNode *newcur = new ListNode(0);
ListNode *newhead = newcur;
while (oldcur) {
int val = oldcur->val;
if (val % 2 == 1) {
ListNode *node = new ListNode(val);
newcur->next = node;
newcur = newcur->next;
}
oldcur = oldcur->next;
}
return newhead->next;
}

以上是本题的全部思路和实现过程，完整代码如下：