求单链表第k个节点用c语言

在C语言中，求单链表的第k个节点通常需要遍历链表。这里有一个简单的算法步骤：

1. 定义一个指针`p`初始化为链表的头节点，然后创建一个辅助变量`count`设置为0，用于计数当前访问的节点。

2. 使用循环，对于每个节点，`p`向前移动一步，并将`count`加一。当`count`等于`k`时，`p`指向的就是第k个节点。如果链表长度小于k，那么返回空指针表示不存在这样的节点。

以下是伪代码和示例代码片段：

typedef struct ListNode {
    int data;
    struct ListNode* next;
} ListNode;

ListNode* findKthNode(ListNode* head, int k) {
    if (head == NULL || k <= 0) return NULL; // 链表为空或k非法

    ListNode* p = head;
    for (int i = 1; i < k; i++) {
        if (p == NULL) return NULL; // 如果到达了链表末尾还没找到k
        p = p->next;
    }

    return p;
}

相关问题

C语言求单链表第K个节点

在C语言中，要找到单链表的第K个节点，通常会采用双指针法，也就是使用两个指向当前节点的指针，其中一个每次前进两步，另一个每次前进一步，直到第一个指针到达第K个节点。以下是简单的步骤：

1. 定义两个指针`p1`和`p2`，初始化为链表头节点；
2. `p2`向前移动K - 1次，因为我们需要找到的是第K个节点；
3. 当`p2`达到第K个节点时，`p1`就是我们要找的位置，因为`p1`此时所在的就是第K个节点；
4. 如果链表长度小于K，那么返回空，表示不存在这样的节点。

以下是一个简单的函数实现示例（假设链表节点结构体定义为`struct ListNode`，包含`val`数据和`next`指向下一个节点的指针）:

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

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

ListNode* findKthNode(ListNode* head, int k) {
    if (head == NULL || k <= 0) {
        return NULL;
    }
    
    ListNode *p1 = head;
    ListNode *p2 = head;

    for (int i = 0; i < k - 1; i++) {
        p2 = p2->next;
    }

    while (p2 != NULL) {
        p1 = p1->next;
        p2 = p2->next;
        if (p1 == p2) {
            break;
        }
    }

    return p1;
}

// 示例
int main() {
    // 初始化链表...
    ListNode* node = findKthNode(head, k);
    if (node) {
        printf("第 %d 个节点值为: %d\n", k, node->val);
    } else {
        printf("链表中没有第 %d 个节点\n", k);
    }
    return 0;
}

查找单链表倒数k节点c语言代码

查找单链表的倒数第K个节点通常需要两个指针同时移动，一个普通指针每次前进一步，另一个快指针每次前进两步。当快指针到达链表尾部时，普通指针就指向了倒数第二个节点。然后，普通指针再向前移动K-1次，即可得到倒数第K个节点。

以下是简单的C语言代码实现这一算法：

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

// 定义链表结构体
typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

ListNode* findKthToTail(ListNode* head, int k) {
    if (head == NULL || k <= 0) {
        return NULL;
    }

    // 快慢指针
    ListNode* slow = head;
    ListNode* fast = head;

    // 当快指针到达链表尾部时，慢指针正好在倒数第二个位置
    for (int i = 0; fast != NULL && fast->next != NULL; i++) {
        fast = fast->next->next;
        if (i == k - 1) {
            break;
        }
        slow = slow->next;
    }

    // 如果找到了倒数第K个节点，返回它；否则返回NULL
    if (fast != NULL) {
        return slow;
    } else {
        return NULL;
    }
}

void printList(ListNode* node) {
    while (node != NULL) {
        printf("%d -> ", node->val);
        node = node->next;
    }
    printf("NULL\n");
}

int main() {
    // 示例：输入链表 1 -> 2 -> 3 -> 4 -> 5 和 k=2
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->val = 1;
    head->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->val = 2;
    head->next->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->next->val = 3;
    head->next->next->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->next->next->val = 4;
    head->next->next->next->next = (ListNode*)malloc(sizeof(ListNode));
    head->next->next->next->next->val = 5;
    head->next->next->next->next->next = NULL;

    int k = 2;
    ListNode* result = findKthToTail(head, k);

    if (result != NULL) {
        printf("The %dth to tail is: %d\n", k, result->val);
    } else {
        printf("Invalid k or empty list.\n");
    }

    printList(head); // 打印链表帮助理解

    return 0;
}

这段代码首先定义了一个单链表结构，然后实现`findKthToTail`函数来找倒数第K个节点。在`main`函数中，我们创建了一个示例链表并测试了这个功能。