Leetcode_237删除链表中的节点_206反转链表_141环形链表

前言

利用闲暇之际敲敲代码，提升编程技能及提高算法能力。

一、删除链表中的节点

1.1 问题描述

有一个单链表的 head，我们想删除它其中的一个节点 node。给你一个需要删除的节点 node 。你将无法访问第一个节点 head。链表的所有值都是唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。删除给定的节点注意：删除节点并不是指从内存中删除它，这里的意思是：

• 给定节点的值不应该存在于链表中。
• 链表中的节点数应该减少 1。
• node 前面的所有值顺序相同。
• node 后面的所有值顺序相同。
  自定义测试：
• 对于输入，你应该提供整个链表 head 和要给出的节点 node。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。
• 我们将构建链表，并将节点传递给你的函数。
• 输出将是调用你函数后的整个链表。
  示例1：
  

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

示例2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为1的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

提示：

• 链表中节点的数目范围是 [2, 1000]
• -1000 <= Node.val <= 1000
• 链表中每个节点的值都是唯一的
• 需要删除的节点 node 是链表中的节点，且不是末尾节点

1.2 思路分析

1.2.1 这题题目的题解很巧妙，传统的思维认定我们是要真正的删除链表中的节点，但这题不是，而是利用了地址覆盖和改变链表引用方向。
1.2.2 代码实现

public class LT237_删除链表中的节点 {

    public class ListNode {
        int val;
        ListNode next;
        ListNode(int x) { val = x; }
    }

    public void deleteNode(ListNode node) {
        //利用next属性，可以获取node下一个节点
        ListNode next = node.next;
        //node下一个节点数据赋值给当前节点
        node.val = next .val;
        //当前节点指向改变：指向next.next, 实际是把node的下一个节点删了
        node.next = next .next;
    }
}

二、反转链表

2.1 问题描述

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例1：

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

示例2：

输入：head = [1,2]
输出：[2,1]

示例3：

输入：head = []
输出：[]

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

2.2 思路分析

2.2.1 递归方法求解：调用 reverseList 方法，当传入 head 时，反转之后的链表应该如下图所示：

当传入 head.next 时，反转之后的链表应该如红色框图所示：

然后再改变 head 节点和 head.next 节点的 next 指向即可。

2.2.2 代码实现

public static  ListNode reverseList(ListNode head) {
    //如果为空链表或者只有一个节点的链表,则返回它本身
    if (head == null || head.next == null) {
        return head;
    }
    //反转head.next部分的链表
    ListNode newHead = reverseList(head.next);
    //head.next执向head原链表头
    head.next.next = head;
    //原链表头的next指向null
    head.next = null;
    //返回newHead反转之后的链表
    return newHead;
}

2.2.3 非递归方法求解：

2.2.4 代码实现

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode newHead = null;
        while (head != null) {
            ListNode tmp = head.next;
            head.next = newHead;
            newHead = head;
            head = tmp;
        }
        return newHead;
    }
}

三、环形链表

3.1 问题描述

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

示例1：

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

示例2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

• 链表中节点的数目范围是 [0, 104]
• -105 <= Node.val <= 105
• pos 为 -1 或者链表中的一个 有效索引 。

3.2 思路分析

3.2.1 快慢指针： 慢指针每次移动一步，快指针每次移动两步。如果链表存在有环的情况，快慢指针存在指向同一个链表节点的情况，类似操场跑圈，一个同学跑得快，另一个同学跑得慢，那么这两位同学肯定会相遇。

public boolean hasCycleOne(ListNode head) {
     if (head == null || head.next == null){
         return false;
     }
     ListNode slow = head;
     ListNode fast = head.next;
     while (fast != null && fast.next != null){
         slow = slow.next;
         fast = fast.next.next;
         if (slow == fast){
             return true;
         }
     }
     return false;
}

3.2.2 Set 集合： 我们遍历链表的时候利用 Set 集合，将节点依次添加到集合中，链表有环，则说明某个节点肯定被添加到集合多次。我们可以利用 Set 的 contains() 方法，来判断是否有重复节点，进而判断链表是否有环。

public boolean hasCycleTwo(ListNode head) {
    if (head == null || head.next == null){
        return false;
    }
    Set<ListNode> list = new HashSet<>();
    ListNode visitor = head;
    while (visitor != null){
        if (list.contains(visitor)){
            //节点重复,则说明链表有环
            return true;
        }
        visitor = visitor.next;
    }
    return false;
}