# Space Complexity

Asymptotic notation is often used to describe the runtime of a program or algorithm, but it can also be used to describe the space, or memory, that a program or algorithm will need. Think about a simple function that takes in two numbers and returns their sum:

```
function addNumbers(a, b) {
return a + b;
}
```

This function has a space complexity of `O(1)`

, because the amount of space it needs will not change based on the input. While this function also has a constant runtime of `O(1)`

, most functions do not have matching space and time complexities:

```
function simpleLoop(inputArray) {
for (let i = 0; i < inputArray.length; i++) {
console.log(i);
}
}
```

As we know, a simple `for`

loop that goes through every element in an array of size n has a linear runtime of `O(n)`

. However, this function takes `O(1)`

space since no new variables are being created and therefore no more space must be allocated.

A recursive function that is passed the same array or object in each call doesn’t add to the space complexity if the array or object is passed by reference (which it is in JavaScript).

Like with time complexity, space complexity denotes space growth in relation to the input size. It’s also important to note that space complexity usually refers to any additional space that will be needed, and doesn’t count the space of the input. So a function could have 10 arrays passed into it, but if all it does inside is print `'Hello World!'`

, then it still takes `O(1)`

space.