奇数值结点链表

习题11-7 奇数值结点链表

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

struct ListNode {
    int data;
    ListNode *next;
};

函数接口定义：

struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );

函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点的指针。

函数getodd将单链表L中奇数值的结点分离出来，重新组成一个新的链表。返回指向新链表头结点的指针，同时将L中存储的地址改为删除了奇数值结点后的链表的头结点地址（所以要传入L的指针）。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬

裁判测试程序样例：

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

struct ListNode {
    int data;
    struct ListNode *next;
};

struct ListNode *readlist();
struct ListNode *getodd( struct ListNode **L );
void printlist( struct ListNode *L )
{
     struct ListNode *p = L;
     while (p) {
           printf("%d ", p->data);
           p = p->next;
     }
     printf("\n");
}

int main()
{
    struct ListNode *L, *Odd;
    L = readlist();
    Odd = getodd(&L);
    printlist(Odd);
    printlist(L);

    return 0;
}

/* 将你的代码嵌在这里，与上述代码一起提交 */

输入样例：

1 2 2 3 4 5 6 7 -1

输出样例：

1 3 5 7 
2 2 4 6 

代码：

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

// 定义链表节点结构体
struct ListNode {
    int data; // 存储数据
    struct ListNode *next; // 指向下一个节点的指针
};

// 函数声明
struct ListNode *readlist(); // 读取链表的函数
struct ListNode *getodd(struct ListNode **L); // 提取奇数节点并重新组织链表的函数

// 打印链表的函数
void printlist(struct ListNode *L) {
    struct ListNode *p = L;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

// 主函数
int main() {
    struct ListNode *L, *Odd; // 定义原始链表和奇数链表的头指针
    L = readlist(); // 读取用户输入，创建链表
    Odd = getodd(&L); // 从原链表中提取奇数节点，返回新的奇数链表
    printlist(Odd); // 打印奇数链表
    printlist(L); // 打印剩余的原链表
    return 0;
}

// 创建链表的函数
struct ListNode *readlist() {
    struct ListNode *head, *p, *q; // 定义头指针、遍历指针和临时节点指针

    head = (struct ListNode*)malloc(sizeof(struct ListNode)); // 为头结点分配内存
    head->next = NULL; // 初始化头结点的 next 指针
    head->data = 0; // 初始化头结点的数据（实际未使用）
    q = head; // q 指向头结点

    while (1) {
        p = (struct ListNode*)malloc(sizeof(struct ListNode)); // 为新节点分配内存
        scanf("%d", &p->data); // 从用户输入读取数据
        if (p->data == -1) // 如果输入为 -1，停止读取
            break;
        q->next = p; // 将新节点连接到链表末尾
        q = p; // 移动 q 指向最新的节点
    }

    q->next = NULL; // 最后一个节点的 next 指针置为空
    return head; // 返回链表头指针
}

// 提取奇数节点并重新组织链表的函数
struct ListNode *getodd(struct ListNode **L) {
    struct ListNode *head = *L, *p; // 定义指向原链表的头节点和遍历指针
    struct ListNode *oddh, *oddp, *oddq; // 定义奇数链表的头指针、临时节点指针和遍历指针

    p = (*L)->next; // 从第一个实际节点开始遍历原链表
    oddh = (struct ListNode*)malloc(sizeof(struct ListNode)); // 为奇数链表创建头结点
    oddh->next = NULL; // 初始化奇数链表头结点的 next 指针
    oddq = oddh; // oddq 指向奇数链表的头结点

    for (; p != NULL; p = p->next) { // 遍历原链表
        if ((p->data) % 2 != 0) { // 如果节点数据是奇数
            oddp = (struct ListNode*)malloc(sizeof(struct ListNode)); // 为奇数节点创建新节点
            oddp->data = p->data; // 复制数据到新节点
            head->next = p->next; // 从原链表中移除该奇数节点
            free(p); // 释放原链表中该节点的内存
            p = head; // 重置 p 为上一个节点，以便继续遍历
            oddq->next = oddp; // 将新节点连接到奇数链表
            oddq = oddp; // 移动 oddq 指向奇数链表的最新节点
            continue; // 继续下一轮循环
        }
        head = head->next; // 如果不是奇数，移动到下一个节点
    }

    oddq->next = NULL; // 终止奇数链表
    head->next = NULL; // 终止修改后的原链表
    *L = (*L)->next; // 更新原链表头指针，跳过虚拟头节点
    oddh = oddh->next; // 移除奇数链表的虚拟头节点

    return oddh; // 返回奇数链表的头指针
}

代码逐行解释：

• 定义链表节点结构体：每个节点包含一个整数数据和一个指向下一个节点的指针。

struct ListNode {
    int data;
    struct ListNode *next;
};

•  函数声明：声明了读取链表、提取奇数节点并重新组织链表以及打印链表的函数。

struct ListNode *readlist();
struct ListNode *getodd(struct ListNode **L);
void printlist(struct ListNode *L);

•  打印链表的函数：遍历链表并打印每个节点的数据。

void printlist(struct ListNode *L) {
    struct ListNode *p = L;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

•  主函数：调用readlist函数读取链表，调用getodd函数从原链表中提取奇数节点，最后分别打印奇数链表和修改后的原链表。

int main() {
    struct ListNode *L, *Odd;
    L = readlist();
    Odd = getodd(&L);
    printlist(Odd);
    printlist(L);
    return 0;
}

• 读取链表的函数：创建链表并读取用户输入的数据，直到输入 -1 停止。

struct ListNode *readlist() {
    struct ListNode *head, *p, *q;
    head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next = NULL;
    head->data = 0;
    q = head;

    while (1) {
        p = (struct ListNode*)malloc(sizeof(struct ListNode));
        scanf("%d", &p->data);
        if (p->data == -1)
            break;
        q->next = p;
        q = p;
    }

    q->next = NULL;
    return head;
}

• 提取奇数节点并重新组织链表的函数：遍历原链表，提取奇数节点构建新的链表，并从原链表中移除这些奇数节点。

struct ListNode *getodd(struct ListNode **L) {
    struct ListNode *head = *L, *p;
    struct ListNode *oddh, *oddp, *oddq;

    p = (*L)->next;
    oddh = (struct ListNode*)malloc(sizeof(struct ListNode));
    oddh->next = NULL;
    oddq = oddh;

    for (; p != NULL; p = p->next) {
        if ((p->data) % 2 != 0) {
            oddp = (struct ListNode*)malloc(sizeof(struct ListNode));
            oddp->data = p->data;
            head->next = p->next;
            free(p);
            p = head;
            oddq->next = oddp;
            oddq = oddp;
            continue;
        }
        head = head->next;
    }

    oddq->next = NULL;
    head->next = NULL;
    *L = (*L)->next;
    oddh = oddh->next;

    return oddh;
}