Sieve of Eratosthenes in 0(n) time complexity

The classical Sieve of Eratosthenes algorithm takes O(N log (log N)) time to find all prime numbers less than N. In this article, a modified Sieve is discussed that works in O(N) time.
Example :

Given a number N, print all prime 
numbers smaller than N

Input : int N = 15
Output : 2 3 5 7 11 13

Input : int N = 20
Output : 2 3 5 7 11 13 17 19

Manipulated Sieve of Eratosthenes algorithm works as follows: 

For every number i where i varies from 2 to N-1:
 Check if the number is prime. If the number
 is prime, store it in prime array.

For every prime numbers j less than or equal to the smallest 
prime factor p of i:
 Mark all numbers i*p as non_prime.
 Mark smallest prime factor of i*p as j

Below is the implementation of the above idea. 

Output :

2 3 5 7 11

Auxiliary Space: O(N)
Illustration:

isPrime[0] = isPrime[1] = 0

After i = 2 iteration :
isPrime[] [F, F, T, T, F, T, T, T] 
SPF[] [0, 0, 2, 0, 2, 0, 0, 0]
 index 0 1 2 3 4 5 6 7

After i = 3 iteration :
isPrime[] [F, F, T, T, F, T, F, T, T, F ]
SPF[] [0, 0, 2, 3, 2, 0, 2, 0, 0, 3 ]
 index 0 1 2 3 4 5 6 7 8 9

After i = 4 iteration :
isPrime[] [F, F, T, T, F, T, F, T, F, F]
SPF[] [0, 0, 2, 3, 2, 0, 2, 0, 2, 3]
 index 0 1 2 3 4 5 6 7 8 9