单链表基本操作，有没有会的人看一下

输入格式:
输入第1行为1个正整数n，表示当前单链表长度；第2行为n个空格间隔的整数，为该链表n个元素的数据域值。第3行为1个正整数m，表示对该链表施加的操作数量；接下来m行，每行表示一个操作，为2个或3个整数，格式为0 k d或1 k。0 k d表示在链表第k个结点后插入一个数据域值为d的结点，若k=0则表示表头插入。1 k表示删除链表中第k个结点，此时k不能为0。注：操作序列中若含有不合法的操作（如在长度为5的链表中删除第8个结点、删除第0个结点等），则忽略该操作。n和m不超过100000。

输出格式:
输出为一行整数，表示实施上述m个操作后的链表，每个整数后一个空格。输入数据保证结果链表不空。

输入样例:
5
1 2 3 4 5
5
0 2 8
0 9 6
0 0 7
1 0
1 6
这个代码为什么不对，连输入都不对

题目不全，最后输出的样例是怎样的？以下一个实现的方法，供参考：

#include <stdio.h>
#include <stdlib.h>
typedef int DataType;
typedef struct Lnode
{
    DataType    data;
    struct Lnode* next;
}ListNode, Node, * LinkList;

LinkList CreateList(int n)
{
    DataType  i;
    LinkList  qt = NULL, head = NULL;
    head = (LinkList)malloc(sizeof(ListNode));
    if (!head)
        return NULL;
    head->next = NULL;
    for (i = 0; i < n; i++)
    {
        qt = (ListNode*)malloc(sizeof(ListNode));
        if (!qt)   break;
        qt->next = NULL;
        scanf("%d", &qt->data);
        qt->next = head->next;
        head->next = qt;
    }
    return head;
}
void InsList(LinkList head, int i, DataType x)
{
    ListNode* p = head, * s = NULL;
    if (!head)  return;
    if (i > 0)  while (p->next && i--)  p = p->next;
    s = (ListNode*)malloc(sizeof(ListNode));
    if (!s)  return;
    s->next = NULL;
    s->data = x;
    s->next = p->next;
    p->next = s;
}
void DelList(LinkList head, int i)
{
    ListNode* p = head, * s = NULL;
    if (i < 1 || !head || !head->next)
        return;
    while (p->next && --i)  p = p->next;
    if (!p->next)
        return;
    s = p->next;
    p->next = s->next;
    free(s);
}
Node* GetData(LinkList H, int i)
{
    Node* p = H;
    if (i < 1 || !H || !H->next)
        return NULL;
    while (p->next && --i)  p = p->next;
    if (!p->next)
        return NULL;
    return p->next;
}
void PrintList(LinkList head)
{
    ListNode* p = NULL;
    if (!head || !head->next)
        printf("NULL");
    else {
        p = head->next;
        while (p != NULL)
        {
            printf(p == head->next ? "%d" : " %d", p->data);
            p = p->next;
        }
    }
    printf("\n");
}
int main()
{
    DataType n, m, k, d, x;
    LinkList L = NULL;

    scanf("%d", &n);
    L = CreateList(n);
    scanf("%d", &m);
    while (m--) {
        scanf("%d", &x);
        switch (x)
        {
        case 0:scanf("%d %d", &k, &d);
               InsList(L, k, d);
               break;
        case 1:scanf("%d", &k);
               DelList(L, k);
               break;
        default:
            break;
        }
    }
    PrintList(L);
    return 0;
}

【以下回答由 GPT 生成】

我可以帮您解决这个问题。这个问题看起来比较简单，我可以给出一个具体的解决方案。

首先，我们可以定义一个Node类来表示链表的结点。每个结点包含一个数据域值和一个指向下一个结点的指针。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

接下来，我们可以定义一个LinkedList类来表示单链表。该类包含一个指向链表头结点的指针和一些基本操作方法。

class LinkedList:
    def __init__(self):
        self.head = None

    def insert(self, k, d):
        if k < 0:
            return
        new_node = Node(d)
        if k == 0:
            new_node.next = self.head
            self.head = new_node
        else:
            cur_node = self.head
            for i in range(k - 1):
                if cur_node is None:
                    return
                cur_node = cur_node.next
            if cur_node is None:
                return
            new_node.next = cur_node.next
            cur_node.next = new_node

    def delete(self, k):
        if k <= 0 or self.head is None:
            return
        if k == 1:
            self.head = self.head.next
        else:
            cur_node = self.head
            for i in range(k - 2):
                if cur_node is None:
                    return
                cur_node = cur_node.next
            if cur_node is None or cur_node.next is None:
                return
            cur_node.next = cur_node.next.next

    def get_list(self):
        res = []
        cur_node = self.head
        while cur_node is not None:
            res.append(cur_node.data)
            cur_node = cur_node.next
        return res

接下来，我们可以根据输入的数据构建链表，并依次执行插入和删除操作。最后输出操作后的链表。

n = int(input())
values = list(map(int, input().split()))
m = int(input())
linked_list = LinkedList()
for value in values:
    linked_list.insert(0, value)
for _ in range(m):
    operation = list(map(int, input().split()))
    if operation[0] == 0:
        linked_list.insert(operation[1], operation[2])
    elif operation[0] == 1:
        linked_list.delete(operation[1])
result = linked_list.get_list()
print(' '.join(map(str, result)))

请注意，我没有对输入数据的合法性进行验证，您可以根据需要添加相应的验证逻辑。此外，为了简化代码，我假设输入数据都是合法的。

希望这个解决方案对您有帮助。如果您有任何其他问题，请随时提问。

【相关推荐】

• 你可以看下这个问题的回答https://ask.csdn.net/questions/7737871
• 除此之外, 这篇博客: 【面试题】【剑指offer】给定一个整数数组nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次，请找出只出现一次的那两个元素。中的 显然，要想从ret中拆出独立的两个元素非常困难，我们可以换个思路，既然ret是那两个元素的异或，那么在ret的二进制一个位置上（如M位）为1，必然两个元素（假设为x1，x2）其中一个的M位为1，另一个为0（异或时，相同为0，相异为一，二进制仅有0和1两种表示方法）。想到这里，那我们可以将原先数组中M为1的分成一组，M位为0的分成一组，相同的元素，必然会分到同一组，再让为1的一组全部异或得到其中一个独立元素，M为0的一组全部异或，得到另一个独立元素。 部分也许能够解决你的问题。