在一个单链表结构中，指针p指向链表的倒数第二个结点；指针s指向新结点，则能将s所指的结点插入到链表未尾的语句组是 （） A. p=p->next; s->next=p; p->next=s B. S--next=NULL; p=p--next; p-snext=s C. p=p->next; s->next=p->next; p->next=s ] D. p=(*p).next; (*s).next=(*p).next; (*p).next=s

A. p=p->next; s->next=NULL; p->next=s

解析：首先需要让p指向倒数第二个结点，因此需要执行 p=p->next。然后将新结点s插入到链表末尾，需要将p所指结点的next指针指向s，同时需要将s的next指针置为NULL，因为它是新的末尾结点。因此，完整的语句组应该是 p=p->next; s->next=NULL; p->next=s。

相关问题

输入一个单链表，输出该链表中倒数第k个结点。

这个问题可以使用双指针来解决。我们可以定义两个指针p1和p2，首先将p1和p2都指向链表的头结点。然后让p1向前移动k个位置，此时p1和p2之间的距离为k。接着让p1和p2同时向前移动，直到p1指向链表的尾结点。此时p2所指向的结点就是链表中倒数第k个结点。

具体的算法实现如下：

1. 定义两个指针p1和p2，都指向链表的头结点。

2. 让p1向前移动k个位置。

3. 接着让p1和p2同时向前移动，直到p1指向链表的尾结点。

4. 此时p2所指向的结点就是链表中倒数第k个结点。

下面是具体的代码实现：

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

def findKthToTail(head, k):
    if not head or k <= 0:
        return None

    p1 = p2 = head
    for i in range(k-1):
        if p1.next:
            p1 = p1.next
        else:
            return None

    while p1.next:
        p1 = p1.next
        p2 = p2.next

    return p2

其中，head为链表的头结点，k为倒数第k个结点。如果链表为空或者k小于等于0，直接返回None。否则，定义两个指针p1和p2，都指向头结点。首先让p1向前移动k-1个位置，然后让p1和p2同时向前移动，直到p1指向链表的尾结点。最后返回p2所指向的结点即可。

用单指针删除单链表中倒数第k个结点

题目描述：

给定一个单链表的头指针和倒数第 k 个结点，要求在单链表中删除该倒数第 k 个结点，并返回删除后的单链表的头指针。

例如，给定单链表为 1->2->3->4->5，倒数第 2 个结点为 4，那么删除该结点后的单链表为 1->2->3->5。

解题思路：

双指针法。可以定义两个指针 slow 和 fast，初始时两个指针同时指向头结点。让 fast 先向前走 k 步，然后 slow 和 fast 同时开始向前走，直到 fast 指向尾结点。

此时，slow 指向的结点就是倒数第 k 个结点的前一个结点。然后我们只需要将 slow 指向的结点的下一个结点删除即可。

需要注意，如果删除的是头结点，那么需要将头指针向后移动一个位置。

代码实现：

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

ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode *slow = head, *fast = head;

// fast 先向前走 k 步
for (int i = 0; i < n; i++) {
fast = fast->next;
}

// 如果 fast 为空，说明删除头结点
if (!fast) {
ListNode *tmp = head;
head = head->next;
delete tmp;
return head;
}

// slow 和 fast 同时向前走
while (fast->next) {
slow = slow->next;
fast = fast->next;
}

// 删除 slow 指向的结点的下一个结点
ListNode *tmp = slow->next;
slow->next = slow->next->next;
delete tmp;

return head;
}