O(1) Space Complexity Meaning

O of one space, or constant space, means the extra memory my algorithm uses doesn't grow with the input size. I'm using just a fixed handful of variables, like a couple of counters, a temp, or two pointers, and that amount is the same whether the input has ten elements or ten million. A real example is summing an array. I keep a single accumulator variable and add each element into it, so no matter how big the array is, I only ever use that one variable, which is O of one space. Reversing an array in place is another good one: I use two pointers, one at each end, and swap, again just a couple of variables. Kadane's algorithm for maximum subarray sum is O of one space too. The contrast is anything that allocates a structure that scales with n, like copying the array into a new array, building a HashMap of all the elements, or returning a result list sized to the input. Those are O of n space. Two subtleties I'd flag. First, by space I mean auxiliary space, so the input array itself doesn't count, only what I add on top. Second, recursion has a hidden cost: even if a recursive function doesn't allocate any data structures, each pending call sits on the stack, so a recursion that's n levels deep is actually O of n space. That means an in-place algorithm written recursively isn't truly constant space. When memory is the constraint, I deliberately favor iterative, in-place approaches to stay at O of one.