代码随想录-Day04

已于 2024-06-02 17:04:05 修改
阅读量361 收藏 7
点赞数 5
分类专栏： 代码随想录 文章标签： java 算法 数据结构
于 2024-05-15 22:17:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ToBewhatyouwannabe/article/details/138925591
版权

24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        while (temp.next != null && temp.next.next != null) {
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;
            node2.next = node1;
            temp = node1;
        }
        return dummyHead.next;
    }
}

这段代码定义了一个名为Solution的类，其中包含一个方法swapPairs，用于实现链表中每相邻两个节点的值进行交换。链表节点的定义（ListNode）虽未直接给出，但可根据上下文推断其结构大致如下：

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

方法逻辑解析：

  1. 创建哑节点（dummyHead）:

    ListNode dummyHead = new ListNode(0);
dummyHead.next = head;
ListNode temp = dummyHead;
    • 创建一个值为0的哑节点dummyHead，其作用是为了简化边界条件处理，避免在交换头节点时的特殊判断。
    • 将dummyHead的下一个节点指向原链表的头节点head。
    • 引入一个辅助指针temp指向dummyHead，用于遍历链表。

  2. 循环交换节点:

    while (temp.next != null && temp.next.next != null) {
    // 交换逻辑
}
    • 循环条件确保至少有两个节点可以参与交换，直到遍历到倒数第二个节点为止。

  3. 具体交换操作:

    ListNode node1 = temp.next;
ListNode node2 = temp.next.next;
temp.next = node2;
node1.next = node2.next;
node2.next = node1;
temp = node1;
    • node1和node2分别暂存待交换的两个节点。
    • 更新temp.next为node2，完成第一次交换，此时temp后的两个节点已经交换。
    • 更新node1.next为node2.next，准备将node1置于node2之后。
    • 更新node2.next为node1，完成第二次交换，恢复链表的连续性。
    • 移动temp到node1，准备下一轮交换。

  4. 返回结果:

    return dummyHead.next;
    • 由于最初的头节点可能已被交换，直接返回dummyHead.next作为新链表的头节点。

总结

这段代码通过引入哑节点简化了链表头节点处理的问题，使用循环和简单的指针操作实现了链表中相邻节点值的成对交换，其时间复杂度为O(n)，空间复杂度为O(1)，是一种高效且简洁的解决方案。

为了将 swapPairs 方法改成符合ACM竞赛模式，我们需要调整代码以使用标准输入和输出，并定义 ListNode 类。以下是修改后的代码：

import java.util.Scanner;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        while (temp.next != null && temp.next.next != null) {
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;
            node2.next = node1;
            temp = node1;
        }
        return dummyHead.next;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取链表的元素个数
        int n = scanner.nextInt();

        // 创建链表并读取链表元素
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        for (int i = 0; i < n; i++) {
            current.next = new ListNode(scanner.nextInt());
            current = current.next;
        }

        // 创建Solution对象并调用swapPairs方法
        Solution solution = new Solution();
        ListNode result = solution.swapPairs(dummy.next);

        // 输出结果链表
        current = result;
        while (current != null) {
            System.out.print(current.val + " ");
            current = current.next;
        }
        System.out.println();
    }
}

说明

  1. 输入格式：

    • 第一行输入一个整数 n，表示链表的元素个数。
    • 接下来的一行输入 n 个整数，表示链表的元素。

  2. 输出格式：

    • 输出经过两两交换后的链表，每个元素之间用空格隔开。

使用示例

假设输入如下：

4
1 2 3 4

程序会输出：

2 1 4 3

因为链表 [1, 2, 3, 4] 经过两两交换后，结果链表为 [2, 1, 4, 3]。

可以将这段代码保存到一个文件中，比如 Main.java，然后在命令行中使用 javac Main.java 进行编译，使用 java Main 运行，并在运行时通过标准输入提供数据。

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
在这里插入图片描述

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        ListNode ans = dummy.next;
        return ans;
    }

    public int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return length;
    }
}

这段代码定义了一个名为Solution的类，其中包含两个方法：removeNthFromEnd和getLength。这两个方法共同作用于单链表（ListNode类型），用于实现从链表的末尾移除第n个节点的功能。

方法一：removeNthFromEnd

功能：移除链表中倒数第n个节点，并返回修改后的链表头节点。

参数：

  • ListNode head：链表的头节点。
  • int n：要移除的节点位置，从链表末尾计数。

逻辑：

  1. 创建哑节点（dummy node）：首先创建一个值为0的新节点dummy，并将它的下一个节点指向head。这样做是为了处理边界情况，即当移除头节点时，可以直接通过dummy返回新的头节点。
  2. 计算链表长度：调用getLength方法获取链表的长度。
  3. 定位并移除目标节点：从哑节点开始遍历，遍历到倒数第n+1个节点（即需要移除节点的前一个节点）停止，然后更新该节点的next指针，绕过待移除节点。
  4. 返回结果：返回dummy.next，即修改后的链表头节点。

方法二：getLength

功能：计算链表的长度。

参数：

  • ListNode head：链表的头节点。

逻辑：

  • 通过一个循环遍历链表，每遇到一个节点就将长度加1，直到链表末尾（head == null）。

总结

这段代码通过引入哑节点简化了对头节点的特殊处理，先计算链表长度，再通过一次遍历定位并移除目标节点，实现了从链表末尾移除指定节点的功能。这种方法的时间复杂度为O(N)，空间复杂度为O(1)，其中N为链表长度。

为了将 removeNthFromEnd 方法改成符合ACM竞赛模式，我们需要调整代码以使用标准输入和输出，并定义 ListNode 类。以下是修改后的代码：

import java.util.Scanner;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }

    ListNode(int x, ListNode next) {
        val = x;
        this.next = next;
    }
}

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        int length = getLength(head);
        ListNode cur = dummy;
        for (int i = 1; i < length - n + 1; ++i) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        return dummy.next;
    }

    public int getLength(ListNode head) {
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return length;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取链表的元素个数
        int n = scanner.nextInt();

        // 创建链表并读取链表元素
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        for (int i = 0; i < n; i++) {
            current.next = new ListNode(scanner.nextInt());
            current = current.next;
        }

        // 读取要删除的第 n 个节点
        int k = scanner.nextInt();

        // 创建Solution对象并调用removeNthFromEnd方法
        Solution solution = new Solution();
        ListNode result = solution.removeNthFromEnd(dummy.next, k);

        // 输出结果链表
        current = result;
        while (current != null) {
            System.out.print(current.val + " ");
            current = current.next;
        }
        System.out.println();
    }
}

说明

  1. 输入格式：

    • 第一行输入一个整数 n，表示链表的元素个数。
    • 接下来的一行输入 n 个整数，表示链表的元素。
    • 最后一行输入一个整数 k，表示要从链表末尾删除的第 k 个节点。

  2. 输出格式：

    • 输出删除第 k 个节点后的链表，每个元素之间用空格隔开。

使用示例

假设输入如下：

5
1 2 3 4 5
2

程序会输出：

1 2 3 5

因为链表 [1, 2, 3, 4, 5] 中删除倒数第 2 个节点后，结果链表为 [1, 2, 3, 5]。

可以将这段代码保存到一个文件中，比如 Main.java，然后在命令行中使用 javac Main.java 进行编译，使用 java Main 运行，并在运行时通过标准输入提供数据。

链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
在这里插入图片描述

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Set<ListNode> visited = new HashSet<ListNode>();
        ListNode temp = headA;
        while (temp != null) {
            visited.add(temp);
            temp = temp.next;
        }
        temp = headB;
        while (temp != null) {
            if (visited.contains(temp)) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }
}

这段代码是一个Java程序，实现了一个名为Solution的类，其中包含一个方法getIntersectionNode。这个方法用于找到两个链表（ListNode类型）的交点，即第一个同时存在于两个链表中的节点。如果两个链表没有交点，该方法返回null。这里的ListNode是一个链表节点类，虽然具体定义没有给出，但通常包含一个值字段（val）和一个指向下一个节点的指针（next）。

方法的具体实现思路是：

  1. 使用HashSet记录第一个链表的所有节点:

    • 首先，程序创建一个名为visited的哈希集（HashSet），用于存储链表A中访问过的节点。
    • 通过一个while循环遍历链表A（headA），将遍历到的每个节点都添加到visited集合中。这样，集合visited最终将包含链表A的所有唯一节点。

  2. 检查第二个链表的节点是否存在于哈希集中:

    • 然后，程序开始遍历链表B（headB），使用另一个while循环，并在每次迭代中检查当前节点temp是否已经在visited集合中。
    • 如果发现某个节点存在于visited集合中，这意味着该节点同时存在于链表A和B中，即为两个链表的交点，于是直接返回这个节点。
    • 如果遍历完链表B都没有找到交点，则返回null，表示两个链表没有交集。

这种方法的时间复杂度为O(m+n)，其中m和n分别是两个链表的长度。空间复杂度也是O(min(m,n))，因为在最坏的情况下，需要存储一个链表的所有节点。这是一种简单直观的解法，但不是最优的，最优解法（如双指针法）可以在O(m+n)时间内完成，且只需O(1)的额外空间。
为了将 getIntersectionNode 方法改成符合ACM竞赛模式，我们需要调整代码以使用标准输入和输出，并定义 ListNode 类。以下是修改后的代码：

import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}

class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Set<ListNode> visited = new HashSet<>();
        ListNode temp = headA;
        while (temp != null) {
            visited.add(temp);
            temp = temp.next;
        }
        temp = headB;
        while (temp != null) {
            if (visited.contains(temp)) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }
}

public class Main {
    private static ListNode buildList(Scanner scanner) {
        int n = scanner.nextInt();
        if (n == 0) return null;
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        for (int i = 0; i < n; i++) {
            current.next = new ListNode(scanner.nextInt());
            current = current.next;
        }
        return dummy.next;
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    private static ListNode findNode(ListNode head, int pos) {
        while (pos-- > 0 && head != null) {
            head = head.next;
        }
        return head;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Build first linked list
        ListNode headA = buildList(scanner);

        // Build second linked list
        ListNode headB = buildList(scanner);

        // Read intersection position for the first list (0-indexed, -1 if no intersection)
        int intersectA = scanner.nextInt();

        // Read intersection position for the second list (0-indexed, -1 if no intersection)
        int intersectB = scanner.nextInt();

        // If both positions are valid, create intersection
        if (intersectA != -1 && intersectB != -1) {
            ListNode nodeA = findNode(headA, intersectA);
            ListNode nodeB = findNode(headB, intersectB);
            if (nodeA != null && nodeB != null) {
                nodeB.next = nodeA;
            }
        }

        // Create Solution object and find the intersection node
        Solution solution = new Solution();
        ListNode intersection = solution.getIntersectionNode(headA, headB);

        // Output the result
        if (intersection != null) {
            System.out.println(intersection.val);
        } else {
            System.out.println("null");
        }
    }
}

说明

  1. 输入格式：

    • 第一个整数表示第一个链表的长度 n。
    • 接下来 n 个整数表示第一个链表的元素。
    • 第二个整数表示第二个链表的长度 m。
    • 接下来 m 个整数表示第二个链表的元素。
    • 一个整数 intersectA 表示第一个链表中的交叉点（0索引，-1表示没有交叉）。
    • 一个整数 intersectB 表示第二个链表中的交叉点（0索引，-1表示没有交叉）。

  2. 输出格式：

    • 输出交点的值，如果没有交点则输出 “null”。

使用示例

假设输入如下：

5
4 1 8 4 5
6
5 6 1 8 4 5
2
3

程序会输出：

8

因为链表在节点值为 8 处相交。

可以将这段代码保存到一个文件中，比如 Main.java，然后在命令行中使用 javac Main.java 进行编译，使用 java Main 运行，并在运行时通过标准输入提供数据。

方法二：双指针

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

这段代码同样定义了一个名为Solution的类，其中包含一个方法getIntersectionNode，用于寻找两个链表（由ListNode节点组成）的交点。与之前提供的解决方案不同，这个方法采用了“双指针”技巧，其核心思想是让两个指针分别从两个链表的头开始遍历，当一个指针到达链表末尾时，将其重新定位到另一个链表的头部继续遍历。这种方法假设链表是循环的，或者两个链表在某个节点相遇（如果有交点的话）。下面是详细解释：

  • 参数说明:

    • headA：链表A的头节点。
    • headB：链表B的头节点。

  • 逻辑步骤:

    1. 初始化指针：定义两个指针pA和pB，分别指向两个链表的头节点headA和headB。

    2. 循环遍历：进入一个循环，条件是pA和pB不相等。在循环体内：

      • 如果pA走到链表末尾（即pA == null），则将其重置为headB的头节点，继续遍历。
      • 如果pB走到链表末尾（即pB == null），则将其重置为headA的头节点，继续遍历。
      • 分别将pA和pB向后移动一位（pA = pA.next 和 pB = pB.next）。

    3. 返回交点：当pA == pB时，说明它们相遇在交点，直接返回该节点。如果循环结束仍未相遇，则说明没有交点，但由于题目的设定保证了如果有交点一定会在有限步内相遇，所以这种情况理论上不会发生，但正确的做法是在循环外部加一个返回null的逻辑以应对非预期情况，尽管在这个特定的循环逻辑中这不是必须的，因为循环必定会结束于一个交点或两指针同时为null（这在给定的代码逻辑中不会发生）。

  • 时间复杂度：O(N+M)，其中N和M分别是两个链表的长度。在最坏的情况下，两个指针会遍历完两个链表的全部节点。

  • 空间复杂度：O(1)，只使用了两个指针，没有使用额外的存储空间。

这种方法巧妙地利用了链表可能形成环的特性（即便原始链表不构成环，通过相互遍历也形成了一个逻辑上的环），从而避免了额外的存储空间（如哈希表）需求，提高了空间效率。

为了将 getIntersectionNode 方法改成符合ACM竞赛模式，我们需要调整代码以使用标准输入和输出，并定义 ListNode 类。以下是修改后的代码：

import java.util.Scanner;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}

class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

public class Main {
    private static ListNode buildList(Scanner scanner) {
        int n = scanner.nextInt();
        if (n == 0) return null;
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        for (int i = 0; i < n; i++) {
            current.next = new ListNode(scanner.nextInt());
            current = current.next;
        }
        return dummy.next;
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    private static ListNode findNode(ListNode head, int pos) {
        while (pos-- > 0 && head != null) {
            head = head.next;
        }
        return head;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Build first linked list
        ListNode headA = buildList(scanner);

        // Build second linked list
        ListNode headB = buildList(scanner);

        // Read intersection position for the first list (0-indexed, -1 if no intersection)
        int intersectA = scanner.nextInt();

        // Read intersection position for the second list (0-indexed, -1 if no intersection)
        int intersectB = scanner.nextInt();

        // If both positions are valid, create intersection
        if (intersectA != -1 && intersectB != -1) {
            ListNode nodeA = findNode(headA, intersectA);
            ListNode nodeB = findNode(headB, intersectB);
            if (nodeA != null && nodeB != null) {
                nodeB.next = nodeA;
            }
        }

        // Create Solution object and find the intersection node
        Solution solution = new Solution();
        ListNode intersection = solution.getIntersectionNode(headA, headB);

        // Output the result
        if (intersection != null) {
            System.out.println(intersection.val);
        } else {
            System.out.println("null");
        }
    }
}

说明

  1. 输入格式：

    • 第一个整数表示第一个链表的长度 n。
    • 接下来 n 个整数表示第一个链表的元素。
    • 第二个整数表示第二个链表的长度 m。
    • 接下来 m 个整数表示第二个链表的元素。
    • 一个整数 intersectA 表示第一个链表中的交叉点（0索引，-1表示没有交叉）。
    • 一个整数 intersectB 表示第二个链表中的交叉点（0索引，-1表示没有交叉）。

  2. 输出格式：

    • 输出交点的值，如果没有交点则输出 “null”。

使用示例

假设输入如下：

5
4 1 8 4 5
6
5 6 1 8 4 5
2
3

程序会输出：

8

因为链表在节点值为 8 处相交。

你可以将这段代码保存到一个文件中，比如 Main.java，然后在命令行中使用 javac Main.java 进行编译，使用 java Main 运行，并在运行时通过标准输入提供数据。

142. 环形链表 II

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

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

不允许修改 链表。

方法一：哈希表

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode pos = head;
        Set<ListNode> visited = new HashSet<ListNode>();
        while (pos != null) {
            if (visited.contains(pos)) {
                return pos;
            } else {
                visited.add(pos);
            }
            pos = pos.next;
        }
        return null;
    }
}

这段代码定义了一个名为Solution的类，其中包含一个方法detectCycle，用于检测一个链表（ListNode类型）中是否存在环，并返回环中的任意一个入口节点。如果链表中没有环，则返回null。这里的ListNode通常包含两个成员：一个值（val）和一个指向下一个节点的指针（next）。

方法的逻辑非常直接：

  1. 初始化：首先，创建一个名为pos的指针指向链表的头节点head，并初始化一个哈希集合（HashSet）visited，用于记录已访问过的节点。

  2. 遍历链表：接下来，进入一个while循环，条件是pos不为null。在循环中：

    • 检查当前节点pos是否已经被访问过（即visited集合中是否包含pos）。
      • 如果已访问过，说明当前节点处于环中，直接返回该节点作为环的入口。
      • 如果未访问过，将当前节点添加到visited集合中，并将pos指针移动到下一个节点（pos = pos.next）。

  3. 未发现环：如果遍历完整个链表都没有发现重复的节点，说明链表中没有环，最后返回null。

时间复杂度：O(N)，其中N是链表中的节点数量。在最坏的情况下，需要遍历整个链表。

空间复杂度：O(N)，因为在最坏情况下，需要将链表中所有节点都存储在哈希集合中。

这种方法简单且易于理解，但需要注意，当链表很长时，哈希集合的使用会增加额外的空间开销。对于空间敏感的应用场景，可以考虑使用“快慢指针”（Floyd判圈算法）方法来检测环，该方法仅使用常数级别的额外空间。

为了将 detectCycle 方法改成符合ACM竞赛模式，我们需要调整代码以使用标准输入和输出，并定义 ListNode 类。以下是修改后的代码：

import java.util.Scanner;
import java.util.HashSet;
import java.util.Set;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}

class Solution {
    public ListNode detectCycle(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;
    }
}

public class Main {
    private static ListNode buildList(Scanner scanner) {
        int n = scanner.nextInt();
        if (n == 0) return null;
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        for (int i = 0; i < n; i++) {
            current.next = new ListNode(scanner.nextInt());
            current = current.next;
        }
        return dummy.next;
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    private static ListNode findNode(ListNode head, int pos) {
        while (pos-- > 0 && head != null) {
            head = head.next;
        }
        return head;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Build the linked list
        ListNode head = buildList(scanner);

        // Read the position of the cycle node (0-indexed, -1 if no cycle)
        int cyclePos = scanner.nextInt();

        // If cyclePos is valid, create cycle
        ListNode cycleNode = findNode(head, cyclePos);
        if (cycleNode != null) {
            ListNode lastNode = cycleNode;
            while (lastNode.next != null) {
                lastNode = lastNode.next;
            }
            lastNode.next = cycleNode;
        }

        // Create Solution object and find the node where the cycle begins
        Solution solution = new Solution();
        ListNode cycleStart = solution.detectCycle(head);

        // Output the result
        if (cycleStart != null) {
            System.out.println(cycleStart.val);
        } else {
            System.out.println("null");
        }
    }
}

说明

  1. 输入格式：

    • 第一个整数表示链表的长度 n。
    • 接下来 n 个整数表示链表的元素。
    • 一个整数 cyclePos 表示循环开始的位置（0索引，-1表示没有循环）。

  2. 输出格式：

    • 输出循环开始的节点的值，如果没有循环则输出 “null”。

使用示例

假设输入如下：

5
3 2 0 -4 1
1

程序会输出：

2

因为链表在节点值为 2 处开始循环。

你可以将这段代码保存到一个文件中，比如 Main.java，然后在命令行中使用 javac Main.java 进行编译，使用 java Main 运行，并在运行时通过标准输入提供数据。

方法二：快慢指针

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow = head, fast = head;
        while (fast != null) {
            slow = slow.next;
            if (fast.next != null) {
                fast = fast.next.next;
            } else {
                return null;
            }
            if (fast == slow) {
                ListNode ptr = head;
                while (ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }
        return null;
    }
}

这段代码是使用Java编写的，它定义了一个名为Solution的类，其中包含一个方法detectCycle，用于检测一个链表（由ListNode节点组成）中是否存在环，并返回环中的入口节点。如果链表无环，则返回null。这里利用了著名的“快慢指针”（Floyd判圈算法）技术来解决此问题。

逻辑解释：

  1. 初始化：首先，定义两个指针slow和fast，均初始化为链表的头节点head。这两个指针将在链表中前进，但fast指针每次移动两个节点，而slow指针每次移动一个节点。

  2. 寻找交点：进入一个循环，条件是fast不为null且fast.next也不为null（防止空指针异常）。在循环中，slow和fast按照各自的速率前进。如果链表中存在环，fast指针最终会追上slow指针（在环内的某个节点相遇）。

  3. 判断是否有环：当fast == slow时，说明链表中存在环。

  4. 寻找环的入口：

    • 一旦发现环，定义一个新的指针ptr从链表头开始移动，同时保持slow指针继续在环内移动。两者以相同的速度（每次移动一个节点）前进，当它们相遇时的节点即为环的入口节点，因为从头节点和环内某点出发，两者到环入口的距离相等。

  5. 无环处理：如果循环结束，说明链表无环，直接返回null。

时间复杂度和空间复杂度：

  • 时间复杂度：O(N)，其中N是链表中的节点数量。在最坏情况下，快指针会遍历链表两次（一次追上慢指针，一次与慢指针从头节点同时出发再次相遇）。
  • 空间复杂度：O(1)，只使用了常数个额外指针，没有使用额外的数据结构。

这种方法相比使用哈希集合减少了空间复杂度，是非常高效的链表环检测算法。

为了将 detectCycle 方法改成符合ACM竞赛模式，我们需要调整代码以使用标准输入和输出，并定义 ListNode 类。以下是修改后的代码：

import java.util.Scanner;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
        next = null;
    }
}

class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow = head, fast = head;
        while (fast != null) {
            slow = slow.next;
            if (fast.next != null) {
                fast = fast.next.next;
            } else {
                return null;
            }
            if (fast == slow) {
                ListNode ptr = head;
                while (ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }
        return null;
    }
}

public class Main {
    private static ListNode buildList(Scanner scanner) {
        int n = scanner.nextInt();
        if (n == 0) return null;
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        for (int i = 0; i < n; i++) {
            current.next = new ListNode(scanner.nextInt());
            current = current.next;
        }
        return dummy.next;
    }

    private static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    private static ListNode findNode(ListNode head, int pos) {
        while (pos-- > 0 && head != null) {
            head = head.next;
        }
        return head;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Build the linked list
        ListNode head = buildList(scanner);

        // Read the position of the cycle node (0-indexed, -1 if no cycle)
        int cyclePos = scanner.nextInt();

        // If cyclePos is valid, create cycle
        ListNode cycleNode = findNode(head, cyclePos);
        if (cycleNode != null) {
            ListNode lastNode = cycleNode;
            while (lastNode.next != null) {
                lastNode = lastNode.next;
            }
            lastNode.next = cycleNode;
        }

        // Create Solution object and find the node where the cycle begins
        Solution solution = new Solution();
        ListNode cycleStart = solution.detectCycle(head);

        // Output the result
        if (cycleStart != null) {
            System.out.println(cycleStart.val);
        } else {
            System.out.println("null");
        }
    }
}

说明

  1. 输入格式：

    • 第一个整数表示链表的长度 n。
    • 接下来 n 个整数表示链表的元素。
    • 一个整数 cyclePos 表示循环开始的位置（0索引，-1表示没有循环）。

  2. 输出格式：

    • 输出循环开始的节点的值，如果没有循环则输出 “null”。

使用示例

假设输入如下：

5
3 2 0 -4 1
1

程序会输出：

2

因为链表在节点值为 2 处开始循环。

你可以将这段代码保存到一个文件中，比如 Main.java，然后在命令行中使用 javac Main.java 进行编译，使用 java Main 运行，并在运行时通过标准输入提供数据。

ToBeWhatYouWannaBe.
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录-day3
jascl的博客
03-06 203
题意：字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。在本题中我们还是利用整体-局部翻转的方法来实现左旋转字符串的操作，通过简单的模拟我们不难得出：我们可以先翻转前k个字符串，再翻转剩下的字符，最后整体翻转即可实现左旋转的效果。所以我们在本章专题里面，主要是使用我们自己构造的函数对字符串进行，操作加深我们对字符串操作的理解，当我们训练熟悉后可以使用库函数直接执行。对字符串进行了翻转，本题在之前翻转字符串的问题的基础上进行了扩展，我们要去掉字符串前后多余的空格和单词之前多余的空格。
代码随想录-算法训练营day61【代码随想录-算法训练营-总结】
upward
06-05 310
代码随想录-算法训练营day61【代码随想录-算法训练营-总结】
代码随想录-Day23
ToBewhatyouwannabe的博客
05-29 1321
这段代码定义了一个名为Solution的类，其中包含一个方法trimBST，用于修剪（裁剪）给定二叉搜索树（BST）中的节点，使得所有节点的值在指定的区间内。修剪操作应当保持二叉搜索树的性质。：首先检查根节点root是否为空。如果为空，直接返回null，因为没有节点需要修剪。rootroot.vallowroot.righttrimBSTrootroot.valhighroot.lefttrimBST：当当前节点值符合条件需要保留时，分别对左子树root.left和右子树root.right递归调用。
代码随想录-Day01
ToBewhatyouwannabe的博客
05-09 274
这段代码实现了在有序数组中进行二分查找的功能。主要步骤如下：定义两个指针 left 和 right，分别指向数组的起始和末尾位置。在循环中，计算中间位置 mid，并获取该位置的元素值 num。如果 num 等于目标值 target，则返回 mid，表示找到了目标值所在的位置。如果 num 大于目标值 target，则将 right 指针向左移动到 mid - 1，缩小搜索范围。如果 num 小于目标值 target，则将 left 指针向右移动到 mid + 1，缩小搜索范围。
代码随想录-Day03
ToBewhatyouwannabe的博客
05-14 332
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。这段代码是用Java编写的，它定义了一个名为Solution的类，其中包含一个方法。这个方法用于从一个链表中移除所有值为val的节点。现在让我们详细解析。
代码随想录-Day02
ToBewhatyouwannabe的博客
05-10 236
中的每个元素平方后进行排序，然后返回这个排序后的新数组。具体实现采用了双指针技巧，从数组两端向中间遍历，比较两个端点元素的平方值大小，将较大的平方值放于结果数组的末尾，逐步填充结果数组。这种方法的优势在于，它只需要遍历原数组一次，并且不需要额外的排序步骤，因为边计算平方边根据值的大小决定存放位置，自然完成了排序，时间复杂度为O(n)，空间复杂度也为O(n)。给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。它的功能是将一个整数数组。
代码随想录 - Day7 - 链表
qq_51762665的博客
04-06 97
一整个数学推导，代码随想录讲的很清楚。最后用快慢指针来做就好了。
代码随想录 - Day11 - 哈希表
qq_51762665的博客
06-20 108
如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数。
代码随想录-day01-二分查找的相关题目推荐
Zui_____的博客
02-05 1868
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。你必须设计并实现时间复杂度为O(log n)的算法解决此问题。示例 1：nums = [[3,4]示例 2：nums = [[-1,-1]示例 3：[-1,-1]nums是一个非递减数组。
代码随想录day04
qq_42467430的博客
12-12 926
链表类
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录-大厂八股文-面试
04-25
"代码随想录-大厂八股文-面试" 从标题和描述中，我们可以看出这篇文章主要讲述的是代码随想录的大厂八股文面试相关知识点。下面将对这些知识点进行详细的解释和总结。 首先，代码随想录是一种常用的编程技巧，旨在...
代码随想录-大厂八股文稀有资源好几百页
04-19
代码随想录-大厂八股文稀有资源好几百页 本资源是一个关于代码面试和算法的综合资源，涵盖了C++、Java、Go等多种编程语言，涉及到Linux操作系统和数据结构等多个领域。以下是从该资源中提取的知识点： 一、C++基础...
00.代码随想录-最强八股文-第3版-无密版本.pdf
07-11
"代码随想录知识星球精华（最强八股文）第三版" 本资源摘要信息中，我们将根据给定的文件信息，生成相关知识点。 标题和描述中的知识点 * 代码随想录知识星球精华（最强八股文）第三版：这是一个关于编程的知识...
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
java Object 转 Integer
servepeople的博客
07-09 282
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1334
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 809
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
最新发布
qq_44304677的博客
07-09 217
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值