链表的倒数第K个节点

题目:输入一个链表,输出该链表中倒数第K个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个结点。
package com.edu;

class LinkNode{                                 //定义一个结点类型
    int val;
    LinkNode link=null;
    public LinkNode(int val) {
        this.val=val;
    }
}

public class FindKthToTail {

    public LinkNode Test(LinkNode lst ,int k){    //判断该链表中是否有结点,和输入的k是否大于1
        if(lst==null && k<=0){
            return null;
        }
        LinkNode head=lst;
        LinkNode kTh =lst;
        for(int i=0;i<k-1;i++){
            if(head.link!=null)
                head=head.link;
            else
                return null;                    //当链表中结点的个数少于K个时,所做的处理
        }
        while(head.link !=null){
            head=head.link;
            kTh = kTh.link;
        }
        return kTh;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkNode first=null;
        LinkNode second =null;
        for(int i=1;i<20;i++){                       //该for循环是用来创建一个结点个数为19的单链表
            LinkNode node = new LinkNode(i);
            if(first ==null){
                first=node;
                second=first;
            }
            else{
                second.link=node;
                second=node;
            }
        }
        /*
        LinkNode third=first;
        while(third!=null){
            System.out.println(third.val);
            third=third.link;
        }
        */
        LinkNode s = new FindKthToTail().Test(first, 10);
        System.out.println(s.val);
    }

}

链表的倒数第K个节点

时间: 2024-09-30 09:48:08

链表的倒数第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个节点

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

删除单链表中倒数第 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个节点 template<class T> class ListNode { public: T Data; ListNode<T> *pNext; ListNode<T> * FindKNode(ListNode<T> * pHead, int k); }; template<class T> ListNode<T> * ListNode<T>::FindKNode(L

14 链表中倒数第K个节点 FindKthToTail

输入一个链表,输出该链表中倒数第k个结点. 核心思想: 两个指针,先让第一个指针和第二个指针都指向头结点,然后再让第一个指正走(k-1)步,到达第k个节点. 然后两个指针同时往后移动,当第一个结点到达末尾的时候,第二个结点所在位置就是倒数第k个节点了 时间复杂度O(n),一次遍历即可 1 /* 2 public class ListNode { 3 int val; 4 ListNode next = null; 5 6 ListNode(int val) { 7 this.val = val;

链表中倒数第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个. 最后得到想要的值. 但是这是不对的,为什么呢?因为题目给出的是单向链表,只能从前往后找. 所以我们需要换一种思路. 定两个指针. 都从链表的头开始走,一个先走一个后走,先走的比后走的快k步. 然后两个人之后每次都走一步. 当先走的走到终点的时候. 那么后走的所在的位置就是倒数第K个节点的位置了. 下面是代码,这次使用STL库中的list完成. /** *单向链表