• Home
• com.github.javadev
• leetcode-in-java
• 1.38
• source code
• complexity.md

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

g0001_0100.s0076_minimum_window_substring.complexity.md Maven / Gradle / Ivy

**Time Complexity (Big O Time):**

1. The program begins by creating an integer array `map` of size 128 to store character frequencies. It iterates through the characters in string `t` once, incrementing the corresponding count in the `map`. This initialization step runs in O(t.length()) time.

2. The main part of the program uses two pointers, `begin` and `end`, to slide through string `s`. This part contains a while loop that iterates through the entire string `s`. In the worst case, the loop can iterate over each character in `s` twice (once for `end` and once for `begin`), so it runs in O(2 * s.length()) time.

3. Within the loop, there is a nested while loop that adjusts the `begin` pointer and updates the minimum window. The number of iterations of this inner loop depends on the length of the window and the contents of string `s` and string `t`. In the worst case, this inner loop can iterate through the entire string `s` once. Therefore, the inner loop's time complexity is O(s.length()).

4. The overall time complexity of the program is dominated by the two iterations over `s`. Therefore, the time complexity is O(s.length()).

**Space Complexity (Big O Space):**

1. The program uses additional space for the integer array `map`, which has a fixed size of 128 characters (assuming ASCII characters). This space complexity is constant, O(1), because the size of `map` does not depend on the input strings `s` and `t`.

2. The program uses several integer variables (`count`, `begin`, `end`, `d`, `head`) to keep track of indices and counts. These variables consume a constant amount of space, which is also O(1).

3. The program does not use additional data structures or arrays that scale with the size of the input strings.

4. Therefore, the space complexity of the program is O(1), or constant space.

In summary, the time complexity of the provided program is O(s.length()), and the space complexity is O(1). The program efficiently finds the minimum window in string `s` containing all characters from string `t`.