c++语言基础15-链表的基础操作3

时间限制：1.000S 空间限制：128MB

题目描述

请编写一个程序，实现以下链表操作：构建一个单向链表，链表中包含一组整数数据。

1. 实现在链表的第 n 个位置插入一个元素，输出整个链表的所有元素。
2. 实现删除链表的第 m 个位置的元素，输出整个链表的所有元素。

要求：

1. 使用自定义的链表数据结构。
2. 提供一个 linkedList 类来管理链表，包含构建链表、插入元素、删除元素和输出链表元素的方法。
3. 在 main 函数中，创建一个包含一组整数数据的链表，然后根据输入的 n 和 m，调用链表的方法插入和删除元素，并输出整个链表的所有元素。

输入描述
每次输出只有一组测试数据。

每组的第一行包含一个整数 k，表示需要构建的链表的长度。

第二行包含 k 个整数，表示链表中的元素。

第三行包含一个整数 S，表示后续会有 S 行输入，每行两个整数，第一个整数为 n，第二个整数为 x ，代表在链表的第 n 个位置插入 x。

S 行输入…

在 S 行输入后，后续会输入一个整数 L，表示后续会有 L 行输入，每行一个整数 m，代表删除链表中的第 m 个元素。

L 行输入…

输出描述
包含多组输出。

每组第一行输出构建的链表，链表元素中用空格隔开，最后一个元素后没有空格。

然后是 S 行输出，每次插入一个元素之后都将链表输出一次，元素之间用空格隔开，最后一个元素后没有空格；

如果插入位置不合法，则输出“Insertion position is invalid.”。

然后是 L 行输出，每次删除一个元素之后都将链表输出一次，元素之间用空格隔开，最后一个元素后没有空格；

如果删除位置不合法，则输出“Deletion position is invalid.”。

输入示例
5
1 2 3 4 5
3
4 3
3 4
9 8
2
1
0
输出示例
1 2 3 3 4 5
1 2 4 3 3 4 5
Insertion position is invalid.
2 4 3 3 4 5
Deletion position is invalid.

链表的插入过程

在链表中，具体插入的过程如下：

找到要插入的位置的前一个节点，将之命名为cur, 要插入的位置的下一个节点，将之命名为tmp, 它们之间的关系是cur -> next = tmp
创建一个新的链表newNode, 将cur的next指针指向newNode， 即cur -> next = nowNode
将newNode的next指针指向tmp, 即newNode -> next = tmp
这样就完成了链表节点的插入过程。转换成代码如下：

// 创建了一个新的 ListNode 结构的节点，值为x, 并将其地址赋给指针 newNode
ListNode *newNode = new ListNode(x);
// 创建了一个名为 tmp 的指针，临时存储当前节点 cur 的下一个节点的地址。
ListNode *tmp = cur ->next;
// 将当前节点 cur 的 next 指针更新为指向新节点 newNode，将新节点插入到当前节点后面。
cur->next = newNode;
// 将新节点 newNode 的 next 指针设置为指向之前临时存储的节点 tmp
newNode->next = tmp;

删除链表

删除链表的过程则比较简单，只需要找到删除节点的前一个节点cur, 并将其next 指针设置为指向当前节点的下下个节点，从而跳过了下一个节点，实现了节点的删除操作。

// cur->next 表示当前节点 cur 的下一个节点
// cur->next->next 表示要删除的节点的下一个节点
// 当前节点 cur 的 next 指针不再指向要删除的节点，而是指向了要删除节点的下一个节点
cur->next = cur->next->next;

打印链表

循环体结束时，表示已经遍历完了整个链表。最后打印一个换行符，用于分隔不同的输出行。

// 打印链表
void printLinklist(ListNode* head) {
    ListNode* cur = head;
    while (cur->next != NULL) {
        cout << cur->next->val << " ";
        cur = cur -> next;
    }
    cout << endl;
}

代码编写

编写过程中我遇到的问题

1. ListLen没有初始化为k

2. 查找插入位置时，没有从1开始，而是习惯性从0开始

 //*******
            for (int i = 1; i < n; i++) {    
                cur = cur->next;
            }

完整代码如下

#include 

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

void printListNode(ListNode *headNode) {
    ListNode* cur = headNode;
    while (cur->next != nullptr) {
        std::cout << cur->next->val << " ";
        cur = cur->next;
    }
    std::cout << std::endl;
}

int main() {
    int k;//构建链表的长度
    while (std::cin >> k) {
        int val;
        ListNode *headNode = new ListNode(0);
        ListNode *cur = headNode;  
        for (int i = 0; i < k; i++) {
            std::cin >> val;
            //*******
            ListNode *newNode = new ListNode(val);
            cur->next = newNode;
            cur = cur->next;
        }
        
        int s;//后续会有s行输入
        std::cin >> s;
        //*********
        int ListLen = k;
        while (s--) {
            int n,x;
            std::cin >> n >> x;
            if (n <= 0 || n > ListLen) {
                std::cout << "Insertion position is invalid." << std::endl;
                continue;
            }
            cur = headNode;
            //*******
            for (int i = 1; i < n; i++) {    
                cur = cur->next;
            }
            //插入节点
            ListNode* newListNode = new ListNode(x);
            ListNode* temp = cur->next;
            cur->next = newListNode;
            newListNode->next = temp;
            ListLen += 1;

            printListNode(headNode);
        }

        int l,m;
        std::cin >> l;
        while (l--) {
            std::cin >> m;
            if (m <= 0 || m > ListLen) {
                std::cout << "Deletion position is invalid." << std::endl;
                continue;
            }
            cur = headNode;
            for (int i = 1; i < m; i++) {
                cur = cur->next;
            }
            //删除节点
            cur->next = cur->next->next;
            ListLen -= 1;

            if (ListLen != 0) printListNode(headNode);
        }

    }
    return 0;
}