求链表中倒数第k个节点

注意鲁棒性和算法效率的典型例题:(头文件省略)

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

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k);

int main()
{
    int i;
    const int N = 50;
    ListNode *head, *p;

    //随机数种子
    srand((unsigned int)time(0));

    //生成链表
    head = p = new ListNode;
    head->data = rand() % 101;
    head->next = nullptr;
    for ( i = 0; i < N; i++)
    {
        p = p->next = new ListNode;
        p->data = rand() % 101;
        p->next = nullptr;
    }

    //输出链表
    for (p = head; p; p = p->next)
    {
        cout << " " << p->data;
    }
    cout << endl;

    //产生随机数
    i = rand() % 101;
    cout << "随机数n=" << i << endl;

    //输出倒数第k个数
    p = FindKthToTail(head, 3);
    if (nullptr == p)
    {
        cout << "find error" << endl;
    }
    else
    {
        cout << "find result: " << p->data << endl;
    }

    cin.get();
    return 0;
}

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
    if (nullptr == pListHead || !k)
        return nullptr;

    int i;
    ListNode *p, *q;
    p = q = pListHead;

    for ( i = 0; i < k-1; i++)
    {
        if (nullptr==p->next)
        {
            return nullptr;
        }
        else
        {
            p = p->next;
        }
    }
    while (nullptr != p->next)
    {
        p = p->next;
        q = q->next;
    }

    return q;
}
时间: 2024-12-17 23:07:01

求链表中倒数第k个节点的相关文章

剑指offer-第三章高质量的代码(输出该链表中倒数第K个节点)

题目:输入一个链表,输出这个链表中倒数第K个节点.(代码的鲁棒性) 思路:用两个指针p1和p2,都指向头节点,开始的时候,p2不动,p1移动k-1次,指向第k个节点.此时,如果p1->next!=null,则同时移动P1和p2.直到p1指向最后一个节点.此时,P2指向倒数第k个节点. C++代码: #include<iostream> using namespace std; struct ListNode { int m_nValue; ListNode* m_pNext; }; Li

C++ 算法之 链表中倒数第k个节点

题目:输入一个链表,输出链表中倒数第k个节点,为了符合大多数人的习惯,本题从1开始计数,即链表的尾巴节点是倒数第一个节点. 方法1:先遍历链表得到链表的个数n,倒数第k个节点就是n-k+1再遍历一次链表,找到第n-k+1个节点就是倒数第k个节点:这种方法遍历两次链表: 方法2:先遍历链表把链表压入一个栈,再出栈,第k次出栈就是第k个节点: 方法3:先反转链表,再遍历 方法4:定义两个指针,第一个指针从链表的头指针开始遍历向前走k-1:第二个指针保持不动,从第k步开始,第二个指针也开始遍历,两个指

经典算法学习——链表中倒数第k个节点

这是剑指Offer中非常经典的一道题,也是在面试笔试中高频出现.题目的详细描述如下:输入一个链表,输出该链表中倒数第k个节点.为了符合大多数人的习惯,从1开始计数,即链表的尾结点是倒数第一个节点. 本题有一个非常直观的解法,就是对链表扫描两遍,第一遍用来记录链表长度为n,第二次从链表头部走(n-k+1)步后,找到的那个节点就是倒数第k个节点.这种算法的问题就是需要扫描链表两遍,显得不是特别聪明. 其实多想想,这个算法模型和栈的形式非常像,我们只要从头开始扫描链表,把扫描到的每一个节点放入栈中,扫

删除单链表中倒数第 k 个节点

思路 1 :两个指针 p1 ,p2 ,p1从头开始遍历,当 p1 到达第 k 个节点时,p2 开始: 当 P1 到达链表的最后一个节点时,p2 所指的节点则为链表中倒数第 k 个节点. public class Node{ public int data; public Node next; public Node(int data){ this.data = data; } public Node removeLastKNode(Node head,int k){ if(head == nul

链表中倒数第K个节点

输入一个链表,输出该链表中倒数第k个结点. class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }} public class Solution { public ListNode FindKthToTail(ListNode head,int k) { ListNode pre=null,p=null; //两个指针都指向头结点 p=head; pre=head; //记录k值

求链表的倒数第k个节点

问题描述:给定一个链表的头节点,求出链表的倒数第k个节点. 分析:这是链表里的经典问题,存在多种解法,下面给大家分享下我的想法. 解法一:很直观的一种做法是从头到尾扫描链表,然后求倒数第k个,但是由于单链表无法从尾部向头部扫描, 因此可以借助其他的辅助空间去存储扫描过的所有节点,例如,数组或栈均可. 解法二:计算出链表中节点的总数为n,根据k 将其转化为正数的第n-k+1个节点,然后在从链表头开始走n-k+1个节点,就是所求. 解法三:可以设置两个指针实现,假设两个指针分别为p1和p2,p1从链

12,求链表的倒数第k个节点《剑指offer》

题目: 输入一个链表,输出该链表中倒数第k个结点. 思路: 两个指针一个先走k步,然后两个一起走,先走的到达终点时后一个指向的就是所求的节点,注意可能长度小于k,这时候应该返回null 代码: /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* FindKthToTail(ListN

22 链表中倒数第k个节点(第3章 高质量的代码-代码的鲁棒性)

题目描述: 输入一个链表,输出该链表中倒数第k个结点. 尾节点是倒数第一个节点 测试用例:   功能测试(第k个节点在中间.是头节点.是尾节点) 特殊输入测试(链表头节点是nullptr指针.链表的头节点个数小于k.k=0) 解题思路: 1)使用两个指针,一个指针先移动k步,如果链表小于k,终止返回nullptr.然后两个指针同时移动,知道后一个指针移出最后一个节点 //实现1/* struct ListNode { int val; struct ListNode *next; ListNod

14.链表中倒数第k个节点

题目描述: ??输入一个链表,输出该链表中倒数第k个结点. 思路分析: ??设置两个指针,一个fast一个slow,都从链表头开始,让fast先走k步,然后两个指针一起走,当fast走到尾部,那么slow指针指向的就是倒数第K个节点. 代码: public class Solution { public ListNode FindKthToTail(ListNode head,int k) { ListNode fast=head; ListNode slow=head; if(head==nu