精华内容
下载资源
问答
  • 主要介绍了Java输出链表倒数第k个节点的相关内容,涉及三种设计思路及代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 输入一个链表,输出该链表倒数第k个结点。 思路: 先定义两个指针,快引用 fast 和慢引用 slow,让 fast 先走 k-1 步,当 fast.next 为空的时候 slow 就是倒数第 k 个节点 看图说明一下 /* public class...

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

    思路:

    先定义两个指针,快引用 fast 和慢引用 slow,让 fast 先走 k-1 步,当 fast.next 为空的时候 slow 就是倒数第 k 个节点

    看图说明一下

     

    /*
    public class ListNode {
        int val;
        ListNode next = null;
     
        ListNode(int val) {
            this.val = val;
        }
    }*/
    public class Solution {
        public ListNode FindKthToTail(ListNode head,int k) {
            if (head == null){
                return null;
            }
            if ( k <= 0 ){
                System.out.println("k 不合法");
                return null;
            }
            ListNode fast = head;
            ListNode slow = head;
            while (k - 1 > 0){
                if (fast.next != null){
                    fast = fast.next;
                    k--;
                }else{
                    System.out.println("没有这个节点");
                    return null;
                }
            }
            while (fast.next != null){
                fast = fast.next;
                slow = slow.next;
            }
            return slow;
        }
     
    }

     

    展开全文
  • 链表倒数第k个节点Java实现)

    千次阅读 2019-03-11 10:48:35
    输入一个链表,输出该链表倒数第k个结点。 解题思路 我解决本题的思路是建立在只遍历一遍链表的基础之上的。 定义两个指向头节点的指针,一个指针走了k-1步之后,二个指针开始走,直到一个指针到达尾节点。...

    题目描述
    输入一个链表,输出该链表中倒数第k个结点。

    解题思路
    我解决本题的思路是建立在只遍历一遍链表的基础之上的。
    定义两个指向头节点的指针,第一个指针走了k-1步之后,第二个指针开始走,直到第一个指针到达尾节点。因为两个指针之间的距离始终保持在k-1步,所以当第一个指针到达尾节点的时候,第二个指针正好到达倒数第k个节点。

    代码实现

    /*
    public class ListNode {
        int val;
        ListNode next = null;
    
        ListNode(int val) {
            this.val = val;
        }
    }*/
    public class Solution {
        public ListNode FindKthToTail(ListNode head,int k) {
            if(head == null || k == 0) {
                return null;
            }
            ListNode temp1 = head;
            ListNode temp2 = head;
            int k_temp1 = 0;
            while(true) {
                if(k_temp1 < k - 1) {
                    if(temp1.next != null) {
                        temp1 = temp1.next;
                        k_temp1++;
                    }
                    else {
                        return null;
                    }
                }
                else {
                    if(temp1.next != null) {
                        temp1 = temp1.next;
                        temp2 = temp2.next;
                    }
                    else {
                        break;
                    }
                }
            }
            return temp2;
        }
    }
    
    展开全文
  • 题目描述:给出一单链表,返回删除单链表的倒数第 K 个节点链表。 题目链接:https://www.nowcoder.com/questionTerminal/e5d90aac4c8b4628aa70d9b6597c0560 import java.io.BufferedReader; import java.io....

    题目描述:给出一个单链表,返回删除单链表的倒数第 K 个节点的链表。
    题目链接https://www.nowcoder.com/questionTerminal/e5d90aac4c8b4628aa70d9b6597c0560

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class findAndDelLastKNode {
    	public static class ListNode {
        	int val;
      	  	ListNode next=null;
        	public ListNode(int val){
            this.val=val;
        	}
        }
        
        public static void printLinkedList(ListNode head){
            ListNode cur=head;
            while(cur!=null){
                System.out.print(cur.val);
                cur=cur.next;
                System.out.print(" ");
            }
    
        }
    
        public static ListNode removeLastKNode(int n,int k,ListNode head){
            if(k<1||head==null){
                return head;
            }
            ListNode fast=head;
            ListNode slow=head;
            while(k>0&&fast.next!=null){
                fast=fast.next;
                k--;
            }
            if(k==1){
                head=head.next;
            }else if (k==0){
                while(fast.next!=null){
                    fast=fast.next;
                    slow=slow.next;
                }
                 slow.next=slow.next.next;
            }
            return head;
    
    
        }
    
        public static ListNode listGenerator(int n,String[] linkedList){
            ListNode head=new ListNode(Integer.parseInt(linkedList[0]));
            ListNode cur=head;
            for(int i=1;i<linkedList.length;i++){
                cur.next=new ListNode(Integer.parseInt(linkedList[i]));
                cur=cur.next;
            }
            cur.next=null;
            return head;
        }
    
        public static void main(String[] args) throws IOException {
            BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
            String [] lineFirst=bufferedReader.readLine().split(" ");
            int n=Integer.parseInt(lineFirst[0]);
            int k=Integer.parseInt(lineFirst[1]);
            String[] linkedList=bufferedReader.readLine().split(" ");
            ListNode head=listGenerator(n,linkedList);
            ListNode result=removeLastKNode(n,k,head);
            printLinkedList(result);
        }
    }
    

    在这里插入图片描述

    展开全文
  • 题目: 输入一个链表,输出该链表倒数第k 个结点。...或者把指针遍历两边,一遍记录总节点数,从而计算出倒数第K个节点正数应该在几个,然后二遍找到目标节点。这样的时间复杂度为O(n2),因为需要遍历

    题目:
    输入一个链表,输出该链表中倒数第k 个结点。为了符合大多数人的习惯,本题从1 开始计数,即链表的尾结点是倒数第1 个结点.例如一个链表有6 个结点,从头结点开始它们的值依次是1 、2、3、4、5 、6。这个链表的倒数第3 个结点是值为4 的结点。
    思路:
    由于链表没有从后往前的指针,因此直接的想法是将每个链表值储存在某些数据结构中,但这样需要额外的空间。或者把指针遍历两边,第一遍记录总节点数,从而计算出倒数第K个节点正数应该在第几个,然后第二遍找到目标节点。这样的时间复杂度为O(n2),因为需要遍历两次。下面介绍更好的方法
    因为目标点距最后一点距离是固定的,那么我们可以用两个指针指向相距为K-1的两个点,当后方的点到达最后节点时,前方节点即为所求。
    此时时间复杂度为O(n),且不需要额外空间。

    public class Solution {
    
        public  ListNode findKthnode(ListNode l1,int k){
            if (l1==null) {
                System.out.println("链表为空");
                return l1;
            }
            if (k<1) {
                System.out.println("k不合理");
                return null;
            }
            ListNode l2 = l1;
            ListNode l3 = l1;
    
            //将j设为0 最终J+1的值就是链表节点数
            int j =0;
            while (l3.next!=null){
                l3 = l3.next;
                //这里j表示指针1走过的距离,即与指针2相差的距离。
                //当相差距离为k-1时,就是应有距离。当大于这个值,第二个指针就要动了
                if (j>=k-1){
                    l2 = l2.next;
                }
                j++;
            }
            //这里j指代链表的节点数,显然当k大于J时,k值就过大了
            if (j+1<k){
                System.out.println("k不合理");
                return null;}
            else return l2;
        }
    }
    
    
    展开全文
  • Java删除链表倒数第K个节点 /** * 删除链表倒数第k个节点 * @param k 倒数第k个节点 * @param head 链表的头结点 * @return 新的头结点 */ public static Node removeLastKthNode(int k, Node head){ if...
  • 链表倒数第k个结点 java 题目描述 输入一个链表,输出该链表倒数第k个结点。 解析: 最佳代码:Java代码,通过校验。代码思路如下:两个指针,先让一个指针和二个指针都指向头结点,然后再让一个指正走(k-...
  • 输入一个链表,输出该链表倒数第k个结点。 2. 解体思路 方法一:简单来说就是先遍历整个链表的长度L,然后根据k,从头节点开始遍历,到L-k,得到相应的节点。 方法二:两个指针,先让一个指针和二个指针都指向...
  • 链表倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = ...
  • 思路:倒数第K个节点,其实也就是正数Length-k+1个节点。 因此,两个指针就完事了,一个先不动,另一个指针先跑k-1步(注意:此时,一个指针跑了k-1,其实此时这个指针距离二个指针为k),然后,两个指针同时...
  • 链表倒数第K个结点(Java

    千次阅读 2018-05-28 20:48:40
    题目:求链表倒数第K个结点思路:用两个指针,一个指针先走k-1步,然后两个指针一起走,当一个指针走到尾节点的时候。二个指针指向的就是倒数第k个节点。代码:...
  • 1、计算出整个链表长度,如果链表长度等于k,直接返回head.next; 2、双指针 fast 和 slow 让fast先走k-1步,为了让下一步遍历结束后slow正好再被删结点的前一位置,需要让fast再走一步,。 3、两指针同时开始...
  • 2.然后让快慢指针一起走,直到走到链表结束,此时慢指针在倒数第K+1个节点,直接执行slow.next=slow.next.next即可。 参考代码: import java.util.*; /* * public class ListNode { * int val; * ListNode ...
  • 实现一种算法,找出单向链表倒数第 k 个节点。返回该节点的值。 示例: 输入: 1->2->3->4->5 和 k = 2 输出: 4 说明: 给定的 k 保证是有效的。 思路: 设置2指针p和q都指向head,p先向前移动 k...
  • 输入一个链表,输出该链表倒数第k个结点。 如果该链表长度小于k,请返回空。 思路: 快慢指针。 import java.util.*; /* * public class ListNode { * int val; * ListNode next = null; * public ...
  • 题目:输入一个链表,输出该链表倒数第K个节点,为了符合大多数人习惯。本题从1开始计数,即链表的尾节点倒数第1个节点。例如:一个链表有六个节点,从头节点开始,它们值分别是1,2,3,4,5,6.这个链表第...
  • 删除链表倒数第N个节点java实现) 题目 给定一个链表,删除链表倒数第 n 个节点并返回头结点。 例如,给定一个链表: 1->2->3->4->5, 并且 n = 2. 当删除了倒数第个节点链表变成了 1->2->...
  •  思路:先定义两个指针p1,p2,让p2先走k步,然后p1,p2一起走,当p2走到最后,p1就在倒数第k个节点了。 public class Solution { public ListNode FindKthToTail(ListNode head,int k) { if(head==null) return ...
  • 删除链表倒数第N个节点 删除链表中的节点 题目描述: 237.删除链表中的节点 请编写一函数,使其可以删除某个链表中给定的(非末尾)节点,你将只被给定要求被删除的节点。 现有一个链表 -- head = [4,5,1,9],...
  • 输入一个链表,输出该链表倒数第k个结点。 分析: 双指针法,让一个指针先走k补,当这个指针走到链表末尾的时候,那么当前指针就是倒数第k个 /* public class ListNode { int val; ListNode next = null; ...
  • 思路1:为了得到倒数第k个结点,很自然的想法是先走到链表的尾端,再从尾端回溯k步。但是单向链表的结点只有从前往后的指针而没有从后往前的指针,因此这种思路行不通。 思路2: 既然不能从尾结点开始遍历这个链表,...
  • 删除链表倒数第N个节点(Java)

    千次阅读 2019-02-13 17:54:59
    用一指针来操作head节点,最好不要直接操作head节点。 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class...
  • 给定一个链表,删除链表倒数第 n 个节点,并且返回链表的头结点。 示例: 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第个节点后,链表变为 1->2->3->5. 说明:给定的 n 保证是...
  • 给定一个链表,删除链表倒数第n个节点并返回链表的头指针 例如, 给出的链表为:1->2->3->4->5, n= 2. 删除了链表倒数第n个节点之后,链表变为1->2->3->5. 备注: 题目保证n一定是有效的 ...
  • 输入一个链表,输出该链表倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点倒数第1个节点。 例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的...
  • 题目: 输入一个链表,输出该链表倒数第k哥... 为了得到第K个结点,很自然的想法是先走到链表的尾端,再从尾端回溯K步。可是我们从链表结点的定义可疑看出本题中的链表 是单向链表,单向链表的结点只有从前往...
  • 思路一:要得到这个倒数第k个节点的,首先遍历这个这个链表,遍历的同时将这个链表放入到一个ArrayList&lt;ListNode&gt;中然后要取这个倒数第k个这个时候只需要求倒数第k的下标就可以了。缺陷,这个主要是在...
  • 一种方法,直接遍历全部链接节点,并得出链表的总长度,这样便可以将倒数第K个节点转换为正向N个节点,但是这种解法并不优雅,代码如下 public static ListNode firstFindKthToTail (ListNode pHead, int k) {...
  • 删除链表倒数第k个节点 简介 链表倒数第k个节点 , 和这篇文章使用的方法一致,就是变成找到倒数k+1个节点,然后进行删除操作即可 上路 方法 /** * 删除链表倒数第k个节点 */ public class Main { ...
  • 先想到的就是将链表中的元素放到一个栈里边保存,然后从栈里边顺序输出第k个值即可,但超出了时间限制。pass 代码: /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,292
精华内容 4,516
关键字:

链表倒数第k个节点java

java 订阅