c,给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

这个问题可以使用双指针来解决。首先，我们定义两个指针`p`和`q`，它们都指向链表的头结点。然后，我们将`p`向前移动`n`个位置。接着，同时移动`p`和`q`，直到`p`指向链表的最后一个结点。此时，`q`所指向的结点就是要删除的结点的前一个结点。

最后，我们将`q`所指向的结点的`next`指针指向`q.next.next`，即跳过要删除的结点。最后返回原链表的头结点即可。

以下是C语言代码实现：

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode *p = head, *q = head;
    for (int i = 0; i < n; i++) {
        p = p->next;
    }
    if (p == NULL) {
        return head->next;
    }
    while (p->next != NULL) {
        p = p->next;
        q = q->next;
    }
    q->next = q->next->next;
    return head;
}

相关问题

C语言，给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

好的，我会帮您解决这个问题。下面是我给出的一种解法：

1. 首先创建两个指针，一个快指针和一个慢指针，初始时都指向链表的头结点。
2. 将快指针向后移动 n 步。
3. 然后同时移动快指针和慢指针，直到快指针指向链表的末尾节点。
4. 此时慢指针指向的节点即为要删除的倒数第 n 个节点的前一个节点。
5. 将慢指针指向的节点的 next 指针指向下一个节点的下一个节点，即跳过了要删除的节点。
6. 返回链表的头结点。

以下是使用 C 语言实现上述算法的示例代码：

#include <stdio.h>
#include <stdlib.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode *fast = head;
    struct ListNode *slow = head;
    
    // 快指针先向后移动 n 步
    for (int i = 0; i < n; i++) {
        fast = fast->next;
    }
    
    // 如果快指针为空，则说明要删除的是头结点
    if (fast == NULL) {
        return head->next;
    }
    
    // 快慢指针同时向后移动，直到快指针指向链表的末尾节点
    while (fast->next != NULL) {
        fast = fast->next;
        slow = slow->next;
    }
    
    // 跳过要删除的节点
    slow->next = slow->next->next;
    
    return head;
}

// 测试代码
int main() {
    // 创建链表
    struct ListNode *head = (struct ListNode *)malloc(sizeof(struct ListNode));
    head->val = 1;
    
    struct ListNode *node1 = (struct ListNode *)malloc(sizeof(struct ListNode));
    node1->val = 2;
    head->next = node1;
    
    struct ListNode *node2 = (struct ListNode *)malloc(sizeof(struct ListNode));
    node2->val = 3;
    node1->next = node2;
    
    struct ListNode *node3 = (struct ListNode *)malloc(sizeof(struct ListNode));
    node3->val = 4;
    node2->next = node3;
    
    struct ListNode *node4 = (struct ListNode *)malloc(sizeof(struct ListNode));
    node4->val = 5;
    node3->next = node4;
    node4->next = NULL;
    
    // 删除倒数第 2 个节点
    int n = 2;
    struct ListNode *newHead = removeNthFromEnd(head, n);
    
    // 输出链表
    while (newHead != NULL) {
        printf("%d ", newHead->val);
        newHead = newHead->next;
    }
    
    return 0;
}

希望能帮到你！如有疑问，请随时问我。

给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。用c语言实现

在C语言中，给定一个链表并删除倒数第n个节点是一个常见的链表操作。由于我们需要遍历链表找到倒数第n个节点，然后再更新链表，所以可以采用双指针的方法来解决这个问题。下面是一种可能的实现：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 删除倒数第n个节点
Node* deleteNthFromEnd(Node* head, int n) {
    if (head == NULL || head->next == NULL) { // 如果链表为空或只有一个元素，直接返回
        return head;
    }

    Node* slow = head; // 指向当前节点
    Node* fast = head; // 指向当前节点

    for (int i = 0; i < n - 1; i++) {
        fast = fast->next; // 快指针先走n-1步
        if (fast == NULL) { // 如果快指针到了尾部还没超过n-1步，说明链表太短，无法删除倒数第n个节点
            return head;
        }
    }

    while (fast->next != NULL) { // 快慢指针同时移动，直到快指针到达尾部
        slow = slow->next;
        fast = fast->next;
    }

    // 删除倒数第n个节点
    slow->next = slow->next->next;

    return head;
}

// 打印链表
void printList(Node* node) {
    while (node != NULL) {
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}

int main() {
    Node* head = createNode(1);
    head->next = createNode(2);
    head->next->next = createNode(3);
    head->next->next->next = createNode(4);
    head->next->next->next->next = createNode(5);

    int n = 2;
    head = deleteNthFromEnd(head, n);
    printList(head); // 输出: 1 -> 2 -> 4 -> 5 -> NULL

    return 0;
}

这个程序首先创建了一个简单的链表，然后通过`deleteNthFromEnd`函数删除了倒数第二个节点（在这个例子中是4），最后打印出处理后的链表。