问题描述
题目描述
请编写一个程序,实现以下链表操作:构建一个单向链表,链表中包含一组整数数据。
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);
}
}