Java-数据结构-链表＜二＞_java detectcycle

承接上文 Java-数据结构-链表＜一＞

一. 链表简单介绍 

见 Java-数据结构-链表＜一＞

二. 链表的代码实现

见 Java-数据结构-链表＜一＞

三. leetcode&牛客实例

1-6 见 Java-数据结构-链表＜一＞

7. leetcode160 相交链表

        给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
自定义评测：
评测系统 的输入如下（你设计的程序 不适用 此输入）：
intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被 视作正确答案 。

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a = headA;
        ListNode b = headB;
        while(a != b){
            a = (a != null ? a.next : headB);
            b = (b != null ? b.next : headA);
        }
        return a;
    }
}

 【1】：

 走到尽头见不到你，于是走过你来时的路，等到相遇时才发现，你也走过我来时的路。【2】

8. leetcode142 环形链表II

        给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null || head.next == null) return null;
        ListNode fast = head;
        ListNode slow = head;
        while(true){
            if(fast == null || fast.next == null) return null;
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast) break;
        }
        fast = head;
        while(fast != slow){
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }
}

本题小结：（1）这个和环形链表I很相似，但是要判断出具体环形的入口

                  （2）在while(true)种设置关于fast遇到不是环形链表的情况提前退出

9. leetcode203 移除链表元素

        给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if(head == null) return null;
        ListNode dummyhead = new ListNode(0);
        dummyhead.next = head; 
        ListNode tail = dummyhead;
        ListNode pre = head;
        while(pre != null){
            if(pre.val == val){
                tail.next = pre.next;
                pre = tail.next;
            }
            else{
                pre = pre.next;
                tail = tail.next;
            }
        }
        return dummyhead.next; 
    }
}

本题小结：（1）对于首，采用dummyhead是不错的选择

                  （2）对于找到要删除的值，在tail连接好后，pre向前移就可以，因为此时的pre没有被比较过

10. leetcode876 链表的中间节点

        给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
 

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        } 
        return slow;
    }
}

11. leetcode 面试题 02.01. 移除重复节点

编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

 输入：[1, 2, 3, 3, 2, 1]
 输出：[1, 2, 3]

class Solution {
    public ListNode removeDuplicateNodes(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode tail = head;
        ListNode pre = head.next;
        HashSet<Integer> set = new HashSet<>();
        set.add(head.val);
        while(pre != null){
            if(set.contains(pre.val)){
                pre = pre.next;
                tail.next = pre;
            }
            else{
                set.add(pre.val);
                pre = pre.next;
                tail = tail.next;
            }
        }
        return head;
    }
}

建立HashSet明显是好做得题目，没有缓冲区怎么办?

也可以使用双重暴力循环来做，花费时间的选项

class Solution {
    public ListNode removeDuplicateNodes(ListNode head) {
        if(head == null || head.next == null) return head;
        ListNode cur = head;
        while(cur != null){
            ListNode temp = cur;
            while(temp.next != null){
                if(cur.val == temp.next.val){
                    temp.next = temp.next.next;
                }
                else{
                    temp = temp.next;
                }
            }
            cur = cur.next;
        }
        return head;
    }
}

11. leetcode 剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

        给定一个链表: 1->2->3->4->5, 和 k = 2.

        返回链表 4->5.

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        Deque<ListNode> list = new ArrayDeque<>();
        ListNode cur = head;
        while(cur != null){
            list.push(cur);
            cur = cur.next;
        }
        while(k > 1){
            list.pop();
            k--;
        }
        return list.pop();
    }
}

 

12. leetcode 61 旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if(head == null || head.next == null) return head;
        int sum = 1;
        ListNode pre = head;
        while(pre.next != null){
            sum++;
            pre = pre.next;
        }
        System.out.println(sum);
        int diff = k % sum;
        System.out.println(diff);
        if(diff == 0) return head;
        ListNode cur = head;
        for(int i = 1; i < sum - diff; i++){
            cur = cur.next;
        }
        ListNode temp = cur.next;
        cur.next = null;
        pre.next = head;
        return temp;
    }
}

本题小结：（1）可以通过取余节省时间（数据量小没用）

                  （2）剩下需要移动的位置就是sum - diff-1了，注意起始值

13. leetcode 19 删除链表的倒数第N个节点

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

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

 双指针，有一个要先走

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null || n < 1){
            return head;
        }
        ListNode prehead = new ListNode(0);
        prehead.next = head;
        ListNode fast = prehead;
        ListNode slow = prehead;
        while(n >= 0){
            fast = fast.next;
            n--;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        if(slow == prehead){
            return head.next;
        }
        slow.next = slow.next.next;
        return prehead.next;
    }
}

栈，装满倒序遍历

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null) return head;
        ListNode dummyhead = new ListNode(0);
        dummyhead.next = head;
        ListNode cur = dummyhead;
        Deque<ListNode> list = new ArrayDeque<>();
        while(cur != null){
            list.push(cur);
            cur = cur.next;
        }
        while(n > 1){
            list.pop();
            n--;
        }
        ListNode pre = list.pop();
        ListNode tail = list.pop();
        tail.next = pre.next;
        return dummyhead.next;
    }
}

 

参考自

【1】leetcode 房建斌学算法 图解相交链表

【2】leetcode  sylin