g0101_0200.s0141_linked_list_cycle.complexity.md Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
**Time Complexity (Big O Time):**
- The program uses two pointers, `fast` and `slow`, to traverse the linked list.
- The `fast` pointer moves twice as fast as the `slow` pointer in each iteration.
The key insight here is that if there is a cycle in the linked list, the `fast` and `slow` pointers will eventually meet (i.e., `fast == slow`). If there is no cycle, the `fast` pointer will reach the end of the list (i.e., `fast == null` or `fast.next == null`) before the `slow` pointer.
Therefore, the time complexity of this algorithm is O(N), where N is the number of nodes in the linked list. This is because in the worst case, when there is no cycle, both pointers will traverse the entire linked list once.
**Space Complexity (Big O Space):**
The space complexity of this algorithm is O(1), which means it uses a constant amount of extra space regardless of the size of the input linked list. This is because it only uses two additional pointers (`fast` and `slow`) to traverse the list and does not rely on additional data structures or recursion that would consume additional memory.
In summary, the time complexity of this program is O(N), and the space complexity is O(1), where N is the number of nodes in the linked list.