There are linear-time algorithms that follow the divide and conquer paradigm. I think these should not be considered as streaming algorithms.

One example is the DC3 algorithm for constructing the suffix array of a text $T$ (given as array in the RAM model). In order to construct a suffix array, you group the characters into triplets, so you get a text with new super-characters. You can do this with an offset of $0,1,2$, which results in three new texts $T_1,T_2,T_3$. Interestingly, you can compute the suffix array if you have the suffix array of $T_1\cdot T_2$ in linear time. Hence the algorithm needs

$$ t(n)= t(2/3 \;n) + O(n) $$

time. This recursion solves clearly to $t(n)=O(n)$. You see that the recursion depth is logarithmic so I would not consider this as a streaming algorithm.

In the streaming model you are only allowed to store constant or poly-logarithmic extra-data while scanning through the input. If you consider a linear time algorithm
that follows the divide and conquer paradigm, you need to store more information and/or you should scan through your data as many times as the depth of the recursion.

One example is the DC3 algorithm for constructing the suffix array of a text $T$ (given as array in the RAM model). In order to construct a suffix array, you group the characters into triplets, so you get a text with new super-characters. You can do this with an offset of $0,1,2$, which results in three new texts $T_1,T_2,T_3$. Interestingly, you can compute the suffix array if you have the suffix array of $T_1\cdot T_2$ in linear time. Hence the algorithm needs

$$ t(n)= t(2/3 \;n) + O(n) $$

time. This recursion solves clearly to $t(n)=O(n)$. I don't see how this can be turned into a streaming algorithm.

Another well known example is the classical linear-time selection algorithm.

There are linear-time algorithms that follow the divide and conquer paradigm. I think these should not be considered as streaming algorithms.

One example is the DC3 algorithm for constructing the suffix array of a text $T$ (given as array in the RAM model). In order to construct a suffix array, you group the characters into triplets, so you get a text with new super-characters. You can do this with an offset of $0,1,2$, which results in three new texts $T_1,T_2,T_3$. Interestingly, you can compute the suffix array if you have the suffix array of $T_1\cdot T_2$ in linear time. Hence the algorithm needs

$$ t(n)= t(2/3 \;n) + O(n) $$

time. This recursion solves clearly to $t(n)=O(n)$. You see that the recursion depth is logarithmic so I would not consider this as an algorithm that passes a constant number of time over the input.

There are linear-time algorithms that follow the divide and conquer paradigm. I think these should not be considered as streaming algorithms.

One example is the DC3 algorithm for constructing the suffix array of a text $T$ (given as array in the RAM model). In order to construct a suffix array, you group the characters into triplets, so you get a text with new super-characters. You can do this with an offset of $0,1,2$, which results in three new texts $T_1,T_2,T_3$. Interestingly, you can compute the suffix array if you have the suffix array of $T_1\cdot T_2$ in linear time. Hence the algorithm needs

$$ t(n)= t(2/3 \;n) + O(n) $$

time. This recursion solves clearly to $t(n)=O(n)$. You see that the recursion depth is logarithmic so I would not consider this as a streaming algorithm.