【卡码网Python基础课 15.链表的基础操作3】

---

题目描述与分析

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

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 行输出，每次删除一个元素之后都将链表输出一次，元素之间用空格隔开，最后一个元素后没有空格；如果删除元素后链表的长度为0，则不打印链表。
如果删除位置不合法，则输出“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.

一、插入链表的过程

我们可以假设这样一个场景：在传递情报过程中，A 的下线是 B , 也就是A.next = B, 现在我们要引入一个 C 充当 A 和 B 之间的中间人，新的关系是 A 的下线是 C , C 的下线是 B，我们可以直接将 C 的next指向 B，但是 B 无法直接表示，之前是用A.next来表示 B 的，即C.next = A.next, 然后再将 A 的next指向 C , 即A.next = C，这样就将新的关系构建完成了。

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

如果要在头节点处插入新的节点 (新的节点成为头节点)：
新节点的next指针指向原来的头节点： new_node.next = head_node
新节点成为新的头节点 new_node = head_node
链表长度 + 1

如果要在非头节点处插入新的节点
找到要插入的位置的前一个节点，将之命名为pre_node
将新节点的next指针指向pre_node的next指针，即new_node.next = pre_node.next
将pre_node的next指针指向新节点，即pre_node.next = new_node
链表长度 + 1

这样就完成了链表节点的插入过程。转换成代码如下：

# 在第 n 个位置插入元素
def insert_at(self, n, data):
    new_node = Node(data)
    if n == 1:  # 头节点的情况
        new_node.next = self.head_node # 新节点的 next 指向原来的头节点
        self.headNode = new_node #  新节点成为新的头节点
        self.length += 1 # 链表长度 + 1
        return new_node
    else:  # 不是头节点的情况
        pre_node = self.get(n - 1) # 使用 get 方法获取要插入位置的前一个节点，命名 pre_node
        if pre_node is not None:
            new_node.next = pre_node.next # 将新节点的 next 指针指向 pre_node 的 next 指针
            pre_node.next = new_node # 将 pre_node 的 next 指针指向新节点
            self.length += 1 # 链表长度 + 1
            return new_node
    return None

二、删除链表的过程

删除链表的过程同样要区分是否有头节点

如果链表不存在头节点：表示链表为空，返回None
如果链表存在头节点 (链表不为空)，要删除头节点
新的头节点指向当前头节点的next节点
链表长度 - 1

如果链表存在头节点，要删除非头节点

找到删除节点的前一个节点pre_node
并将其next 指针设置为指向下下个节点，从而跳过了下一个节点，实现了节点的删除操作。
链表长度 - 1

def delete(self, n):
    if self.headNode is None:  # 判断头节点是否还存在, 即链表是否为空链表
        return None
    if n == 1:  # 如果要删除头节点
        deleted_node = self.headNode
        self.headNode = self.headNode.next # 当前头节点的下一个节点成为新的头节点
        self.length -= 1
        return deleted_node
    else: # 如果要删除的不是头节点
        pre_node = self.get(n - 1) # 找到要删除的前一个节点
        if pre_node is not None and pre_node.next is not None:
            deleted_node = pre_node.next 
            pre_node.next = pre_node.next.next # 跳过要删除的节点
            self.length -= 1 # 链表长度 -1
            return deleted_node # 返回要删除的节点
    return None

三、代码编写

首先，需要接收整数 k , 表示需要构建链表的长度，然后我们获取输入的 k 个数字，将其插入到新构建的链表中。

k = int(input()) # k 表示构建链表的长度
link_list = LinkList() # 新建一个链表
elements = list(map(int, input().split())) # 获取链表各位元素
for data in elements:
    link_list.insert(data) # 将输入插入到链表中

之后，需要接收一个整数 s 表示 s 行输入，每行两个整数，第一个整数为 n，第二个整数为 x，代表在链表的第 n 个位置插入 x。

s = int(input()) #  整数 s 表示后续会有 s 行输入
for i in range(s):
    n, x = map(int, input().split()) # 在链表的第 n 个位置插入 x
    node = link_list.insert_at(n, x) # 插入链表时，成功插入返回对应的节点，否则返回 None
    if node is not None: # 成功插入后，打印链表
        link_list.print_link_list()
    else: # 插入位置不合法
        print("Insertion position is invalid.")

链表节点删除的前置步骤类型，需要接收一个整数 l，表示后续会有 l 行输入，每行一个整数 m，代表删除链表中的第 m 个元素。

l = int(input()) # 整数 l 表示后续会有 l 行输入
for j in range(l):
    m = int(input()) # 在链表的第 m 个位置删除
    if link_list.delete(m) is not None: # 删除链表节点时，成功删除返回对应的节点，否则返回 None
        link_list.print_link_list() # 成功删除时，打印链表
    else: # 删除位置不合法
        print("Deletion position is invalid.")

完整代码如下：

# 定义链表节点
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 self.head_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:
            deleted_node = self.head_node
            self.head_node = self.head_node.next
            self.length -= 1
            return deleted_node
        else:
            pre_node = self.get(n - 1)
            if pre_node is not None and pre_node.next is not None:
                deleted_node = pre_node.next
                pre_node.next = pre_node.next.next
                self.length -= 1
                return deleted_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 处删除链表节点
    deleted_node = link_list.delete(m)
    if deleted_node is not None:
        link_list.print_link_list()
    else:
        print("Deletion position is invalid.")