Big O Notation: Understanding Space Complexity with Java Examples

📚 Quick Study Guide

• 💾 Space complexity measures the amount of memory an algorithm uses as a function of the input size.
• 📈 Big O notation expresses the upper bound of this space usage.
• 🔑 Common space complexities include: $O(1)$ (constant), $O(log \space n)$ (logarithmic), $O(n)$ (linear), $O(n \space log \space n)$, $O(n^2)$ (quadratic).
• 🧠 Auxiliary space refers to the extra space used by the algorithm, excluding the input.
• 💡 When analyzing space complexity, consider the space used by variables, data structures, and function call stack.
• ☕ In Java, object creation and array allocation contribute significantly to space complexity.

🧪 Practice Quiz

1. Question 1: What does $O(1)$ space complexity signify?
   1. Constant space usage, regardless of input size
   2. Space usage grows linearly with input size
   3. Space usage grows logarithmically with input size
   4. Space usage grows quadratically with input size
2. Question 2: Which of the following Java code snippets has a space complexity of $O(n)$?
   1. int x = 5;
   2. int[] arr = new int[n];
   3. int[][] matrix = new int[n][n];
   4. List list = new ArrayList<>();
3. Question 3: What is auxiliary space in the context of space complexity?
   1. The total space used by the algorithm, including input
   2. The extra space used by the algorithm, excluding input
   3. The space used by the input data
   4. The space used by the output data
4. Question 4: A recursive function that calls itself $n$ times without tail-call optimization will likely have what space complexity?
   1. $O(1)$
   2. $O(log \space n)$
   3. $O(n)$
   4. $O(n^2)$
5. Question 5: Which data structure operation generally contributes most to space complexity?
   1. Accessing an element
   2. Searching for an element
   3. Inserting an element
   4. Deleting an element
6. Question 6: What is the space complexity of the following Java code?

   int sum = 0;
   for (int i = 0; i < n; i++) {
    sum += i;
   }

   1. $O(1)$
   2. $O(log \space n)$
   3. $O(n)$
   4. $O(n^2)$
7. Question 7: Which of these sorting algorithms generally has the LOWEST space complexity?
   1. Merge Sort
   2. Quick Sort
   3. Bubble Sort
   4. Heap Sort