这个O（1）空间怎么样而不是O（n）空间。 firstNotRepeatingCharacter挑战解决方案

Question

I am having trouble understanding how the following solution is O(1) space and not O(n) space. The coding challenge is as follows:

Write a solution that only iterates over the string once and uses O(1) additional memory, since this is what you would be asked to do during a real interview.

Given a string s, find and return the first instance of a non-repeating character in it. If there is no such character then return '_'.

The following is a solution that is O(1) space.

 function firstNotRepeatingCharacters(s: string) : string { const chars: string[] = s.split(''); let duplicates = {}; let answer = '_'; let indexAnswer = Number.MAX_SAFE_INTEGER; chars.forEach((element, index) => { if(!duplicates.hasOwnProperty(element)) { duplicates[element] = { count: 1, index } } else { duplicates[element].count++; duplicates[element].index = index; } }); for(const key in duplicates) { if(duplicates[key].count === 1 && duplicates[key].index < indexAnswer) { answer = key; indexAnswer = duplicates[key].index; } } return answer; } console.log(firstNotRepeatingCharacter('abacabad')); console.log(firstNotRepeatingCharacter('abacabaabacaba')); 

I do not understand how the above solution is O(1) space. Since we are iterating through our array we are mapping each element to an object (duplicate). I would think this would be considered O(n), could somebody clarify how this is O(1) for me. Thanks.

Answer 1

The memory usage is proportion to the number of distinct characters in the string. The number of distinct characters has an upper limit of 52 (or some other finite value) and the potential memory usage does not increase as n increases once each of the distinct characters has been seen.

Thus, there exists an upper limit on the memory usage that is constant (does not depend on n ), so the memory usage is O(1).

Answer 2

The algorithm has O(min(a,n)) space complexity (where a is number of letters used for text cooding eg for UTF8 a>1M ). For worst case: string with uniqe characters (in this case n<=a ) eg abcdefgh the duplicates object has the same number of keys as number letters of input string - and what is clear on this case, the size of used memory depends on n .

The O(1) is only for case when string contains one repeated letter eg aaaaaaa .

Bonus : Your code can be "compressed" in this way :)

 function firstNotRepeatingCharacters(s, d={}, r="_") { for(let i=0; i<s.length; i++) d[s[i]]=++d[s[i]]|0; for(let i=s.length-1; i>=0; i--) if(!d[s[i]]) r=s[i]; return r; } console.log(firstNotRepeatingCharacters('abacabad')); console.log(firstNotRepeatingCharacters('abacabaabacaba')); 

Answer 3

Indeed this is an 0(1) complexity, but only on space constraints. Since we have an upper limit. This limit could be UTF-16, it could be the amount of English letters.

This is a constraint given by the Developer. Saying that, it's only a 0(1) in space constraints if the code above ran with a finite set of combinations.

A String it's limited by implementation to a 64 bit character "array". So the store capacity generally of a "String" type it's 2147483647 (2ˆ31 - 1) characters. That's not really what 0(1) represents. So virtually that's an 0(N) in space constraints.

Now the situation here it's totally different for time complexity constraints. It should be in the optimal scenario a 0(N) + 0(N - E) + 0(N).

Explaining: 1. First 0(N) the first loop goes through all the elements 2. Second 0(N) is about the deletion. The code delete's element's from the array. 3. 0(N - E) the second forEach loops the final popped array, so we have a constant E.

And that's supposing that the data structure is an Array.

There's a lot to Digg here.

TL;DR

It's not a 0(1).