Java算法 合并两个有序链表、判断是否为回文链表、环形链表Ⅱ返回入环的第一个节点

小王的Java刷题日记Day4

记录刷题过程，作为笔记和分享，坚持每天刷题，每天进步，编程语言为Java。

题目一：合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。例如List1为1->2->5, List2为1->3->4。那么合并后的链表应该是1->1->2->3->4->5。

思路一：迭代法         时间复杂度：O(n+m)

1、首先，我们设定一个哨兵节点 prehead（即虚拟头节点） ，这可以在最后让我们比较容易地返回合并后的链表。我们再设定一个 p 指针，通过p指针将合并链表串起来，也就是调整它的 next 指针。

2、如果 List1 当前节点的值小于等于 List2 ，我们就把List1 当前的节点接在 p节点的后面同时将 List1指针往后移一位。否则，我们对List2做同样的操作。不管我们将哪一个元素接在了后面，我们都需要把 p 向后移一位。

3、在循环终止的时候，List1 和List2至多有一个是非空的。由于输入的两个链表都是有序的，所以不管哪个链表是非空的，它包含的所有元素都比前面已经合并链表中的所有元素都要大。这意味着我们只需要简单地将非空链表接在合并链表的后面，并返回合并链表即可。

/** Java类的定义，用于表示单向链表节点的数据结构。
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode prehead=new ListNode(-1);     //prehead为虚拟头节点
        ListNode p=prehead;
        while(list1!=null&&list2!=null){
            if(list1.val<=list2.val){
                p.next=list1;
                list1=list1.next;
                p=p.next;
            }
            else{
                p.next=list2;
                list2=list2.next;
                p=p.next;
            }
        }
        p.next=list1==null?list2:list1;
        return prehead.next; //因为prehead是虚拟头节点，它的next才是真正合并后链表的头节点。
    }
}

思路二：递归法           时间复杂度：O(n+m)

我们可以如下递归地定义两个链表里的 mergeTwoLists 操作（忽略边界情况，比如空链表等）：

也就是说，两个链表头部值较小的一个节点与剩下元素的 mergeTwoLists 操作结果合并。

1、如果 List1或者 List2一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。

2、若都不为空，则我们要判断 List1和List2哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。

/**一个Java类的定义，用于表示单向链表节点的数据结构
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null) {
            return list2;
        } else if (list2 == null) {
            return list1;
        } else if (list1.val < list2.val) {
            list1.next = mergeTwoLists(list1.next, list2);
            return list1;
        } else {
            list2.next = mergeTwoLists(list1, list2.next);
            return list2;
        }
    }
}

题目二：判断是否为回文链表         

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

思路一：将值复制到数组中，然后用双指针法       时间复杂度O(n)

1、我们知道若判断数组是否回文时，只需要将两个指针指向第一个和最后一个，依次移动判断即可。

2、那么，在链表中，我们无法直接知道最后一个节点的位置。所以我们只需要将其值复制到数组中，然后用双指针进行比较即可。

/**Java类，定义单链表结构体
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
    List<Integer>arr=new ArrayList<Integer>();  //创建数组
    ListNode currentNode=head;
    while(currentNode!=null){                   //遍历链表，复制值到数组中
        arr.add(currentNode.val);
        currentNode=currentNode.next;
    }
    //使用双指针判断是否回文
    int front=0;
    int last=arr.size()-1;
    while(front<last){
        if(!arr.get(front).equals(arr.get(last))){
            return false;
        }
        front++;
        last--;
    }
    return true;
    }
}

思路二：递归法           时间复杂度O(n)

使用递归反向迭代节点，同时使用递归函数外的变量向前迭代，就可以判断链表是否为回文。

1、currentNode 指针是先到尾节点，由于递归的特性再从后往前进行比较。frontPointer 是递归函数外的指针。若 currentNode.val != frontPointer.val 则返回 false。反之，frontPointer 向前移动并返回 true。

2、更加详细的解释在代码的注释中体现。

/** 定义单链表的结构体
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    private ListNode frontPointer;  // 前指针，用于比较回文链表的值

    // 递归检查回文链表
    private boolean recursivelyCheck(ListNode currentNode) {
        if (currentNode != null) {
            if (!recursivelyCheck(currentNode.next)) {  // 递归检查下一个节点
                return false;  // 如果下一个节点不是回文，则链表不是回文，返回false
            }
            if (currentNode.val != frontPointer.val) {  // 比较当前节点的值与前指针指向的节点的值
                return false;  // 如果值不相等，则链表不是回文，返回false
            }
            frontPointer = frontPointer.next;  // 前指针指向下一个节点
        }
        return true;  // 如果所有节点都满足回文条件，返回true
    }

    // 判断链表是否是回文链表
    public boolean isPalindrome(ListNode head) {
        frontPointer = head;  // 初始化前指针为链表头节点
        return recursivelyCheck(head);  // 递归检查链表是否回文
    }
}

题目三：   环形链表Ⅱ --返回链表入环的第一个节点

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。如果无环则返回null。

如图，要返回索引为1的链表节点。

思路一：双指针法     时间复杂度O(n)

1、通过数学推导我们发现从相遇点到入环点的距离加上 n−1 圈的环长，恰好等于从链表头部到入环点的距离.

2、因此，当发现 slow 与 fast 相遇时，我们再额外使用一个指针 count。起始，它指向链表头部；随后，它和 slow 每次向后移动一个位置。最终，它们会在入环点相遇。

3、更多详细解释已注解在代码块中。

/**定义的单链表的结构体
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        // 判断链表为空或只有一个节点的情况
        if (head == null || head.next == null)
            return null;

        // 初始化慢指针和快指针，都指向链表的头部
        ListNode slow = head;
        ListNode fast = head;

        // 使用快慢指针判断是否存在环
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;

            // 如果快慢指针相遇，说明存在环，此时找环的起点
            if (slow == fast) {
                // 重新初始化一个指针从链表头部出发
                ListNode count = head;

                // 遍历找到环的起点
                while (count != slow) {
                    count = count.next;
                    slow = slow.next;
                }

                // 返回环的起点
                return count;
            }
        }

        // 如果循环结束仍未找到环，则返回null
        return null;
    }
}

思路二：哈希表                               时间复杂度O(n)    较简单

1、我们遍历链表中的每个节点，并将它记录下来

2、一旦遇到了此前遍历过的节点，就可以判定链表中存在环。借助哈希表可以很方便地实现。

3、更加详细的解释注解在代码块中。

注意：我们在这里用的是Set而不是List的原因是：Set是一种集合数据结构，可以确保其中的元素是唯一的，不重复的。这对于检测环路非常有用，因为如果存在环路，必然会出现重复的节点。通过将已访问过的节点添加到Set中，并在每次访问节点之前检查是否已经存在于Set中，可以快速检测出是否存在环路。

public class Solution {
    // 检测环路，并返回环路的起始节点
    public ListNode detectorCycle(ListNode head) {
        ListNode pos = head; // 当前节点指针
        Set<ListNode> visited = new HashSet<>(); // 用于存储已访问过的节点

        while (pos != null) {
            if (visited.contains(pos)) { // 如果当前节点已经在已访问集合中，说明存在环路
                return pos; // 返回环路的起始节点
            } else {
                visited.add(pos); // 将当前节点添加到已访问集合中
            }
            pos = pos.next; // 移动到下一个节点
        }

        return null; // 如果不存在环路，返回null
    }
}