卡码网编程基础课 | 链表的基础操作III

问题描述

题目描述

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

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.

python解法

# 定义链表节点
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 定义链表
class LinkedList:
    def __init__(self):
        self.head_node = None
        self.length = 0
    
    # 尾部插入法
    def insert(self, data):
        self.length += 1
        new_node = Node(data)
        if self.head_node is None:
            self.head_node = new_node
            return new_node
        else:
            current_node = self.head_node
            while current_node.next is not None:
                current_node = current_node.next
            current_node.next = new_node
            return new_node
    
    # 获取第 n 个节点
    def get(self, n):
        if n < 1 or n > self.length:
            return None
        i = 1
        current_node = self.head_node
        while current_node is not None:
            if i == n:
                return current_node
            i += 1
            current_node = current_node.next
        return None
        
    # 在提供的位置插入
    def insert_at(self, n, data):
        new_node = Node(data)
        if n == 1:
            new_node.next = self.head_node
            self.head_node = new_node
            self.length += 1
            return new_node
        else:
            pre_node = self.get(n - 1)
            if pre_node is not None:
                new_node.next = pre_node.next
                pre_node.next = new_node
                self.length += 1
                return new_node
        return None
        
    # 删除节点
    def delete(self, n):
        if self.head_node is None:
            return None
        if n == 1:
            delete_node = self.head_node
            self.head_node = self.head_node.next
            self.length -= 1
            return delete_node
        else:
            pre_node = self.get(n - 1)
            if pre_node is not None and pre_node.next is not None:
                delete_node = pre_node.next
                pre_node.next = pre_node.next.next
                self.length -= 1
                return delete_node
        return None
    
    # 打印链表节点
    def print_link_list(self):
        current_node = self.head_node
        while current_node is not None:
            if current_node.next is not None:
                print(current_node.data, end=' ')
            else:
                print(current_node.data)
            current_node = current_node.next
            

k = int(input())
# 新建链表
link_list = LinkedList()
elements = list(map(int, input().split()))
# 将元素插入到链表中
for data in elements:
    link_list.insert(data)
    
s = int(input())
for _ in range(s):
    n, x = map(int, input().split())
    # 在索引 n 处插入链表节点
    node = link_list.insert_at(n, x)
    if node is not None:
        link_list.print_link_list()
    else:
        print("Insertion position is invalid.")
        
l = int(input())
for _ in range(l):
    m = int(input())
    # 在索引 m 处删除链表节点
    delete_node = link_list.delete(m)
    if delete_node is not None:
        link_list.print_link_list()
    else:
        print("Deletion position is invalid.")

C++解法

# include<iostream>
// 定义链表结构体
struct ListNode{
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

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

int main(){
    int k, val;
    std::cin >> k;
    
    int listLen = k;    // 记录链表长度,用来控制非法输入

    ListNode* dummyHead = new ListNode(0);    // 创建虚拟头节点
    ListNode* cur = dummyHead;  // 定义指针cur,初始指向虚拟头节点,便于后续链表操作
    
    // 链表赋值
    for (int i = 0; i < k; i++){
        std::cin >> val;
        ListNode *newNode = new ListNode(val);
        cur->next = newNode;
        cur = cur->next;
    }
    
    // 增加节点
    int s, n, x;
    std::cin >> s;
    while (s--){
        std::cin >> n >> x;
        if (n <= 0 || n > listLen){
            std::cout << "Insertion position is invalid." << std::endl;
            continue;
        }    
        // 指针重新指向虚拟头节点,准备用cur遍历列表
        cur = dummyHead;
        
        // 寻找添加节点的位置
        for (int i = 1; i < n; i++) cur = cur->next;
        
        // 插入节点
        ListNode *newNode = new ListNode(x);
        ListNode *temp = cur->next;
        cur->next = newNode;
        newNode->next = temp;
        // 链表长度加1
        listLen++;
        
        printLinkList(dummyHead);
    }
    
    
    // 删除节点
    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 = dummyHead;
        
        // 寻找删除节点的位置
        for (int i = 1; i < m; i++) cur = cur->next;
        // 删除节点
        cur->next = cur->next->next;
        // 链表长度减1
        listLen--;
        
        // 如果删除节点后，链表不为空，则打印节点
        if (listLen != 0) printLinkList(dummyHead);
    }
}