On average, the performance will be linear.
items you're selecting (1000 in this case).
earlier.
Thanks for your great reply, Anthony!
I have one more comment.
Given that partion will always put the first half of the data to the
left
and the second half to the right of the middle,
and we only apply the algorithm to the half that our nth element is
in,
we
end up with
n/2 + n/4 + n/8 + ...
Even with very large N, the sum above is never greater than N,
therefore
the
algorithm is linear.
From your analysis, I agree that partition itself is linear,
i.e. one round of partition algorithm is linear.
But each time, we get the middle is an optimum and random result.
How could we ensure that each time, the pivot key is in the middle?
Maybe it is 1/3n, maybe it is 7/8n... (if correct me if I am wrong and
such
situation
can not happen), and if such situation exists, is your above analysis
and
conclusion
still working?
have a nice weekend,
George
"Anthony Wieser" wrote:
"George" <George@discussions.microsoft.com> wrote in message
news:BB67AA52-2D38-4867-B0BB-5275B5CEB258@microsoft.com...
Thanks Anthony,
Here is what I find an open source STL implementation of nth_element
algorithm. And I do not think it is linear. Could you help to review
and
comment please?
http://www.google.com/codesearch?hl=zh-CN&q=+nth_element+show:_LKSEhOaCKY:4U8FyRrKZWA:fOIA67E1HTo&sa=N&cd=1&ct=rc&cs_p=http://standards.iso.org/ittf/PubliclyAvailableStandards/c043931_ISO_IEC_14496-5_2001_Amd_9_2007_Reference_Software.zip&cs_f=C043931e_Electronic_inserts/Systems/Systems/IM1/IM1Decoders/AFX/WaveSurf/stlport/stl/_algo.c#first
// nth_element() and its auxiliary functions.
template <class _RandomAccessIter, class _Tp, class _Compare>
void __nth_element(_RandomAccessIter __first, _RandomAccessIter
__nth,
_RandomAccessIter __last, _Tp*, _Compare __comp) {
while (__last - __first > 3) {
_RandomAccessIter __cut =
__unguarded_partition(__first, __last,
_Tp(__median(*__first,
*(__first + (__last -
__first)/2),
*(__last - 1),
__comp)),
__comp);
The partition algorithm is linear, there are (_Last - _First)
applications
of _Comp and at most (_Last - _First)/2 swaps.
The 3 is an arbitrary constant, which is for efficiency or because of
guard
conditions inside the algorithm, because once you've got that close,
insertion sort is as good as linear too.
Given that partion will always put the first half of the data to the
left
and the second half to the right of the middle,
and we only apply the algorithm to the half that our nth element is
in,
we
end up with
n/2 + n/4 + n/8 + ...
Even with very large N, the sum above is never greater than N,
therefore
the
algorithm is linear.
if (__cut <= __nth)
__first = __cut;
else
__last = __cut;
}
__insertion_sort(__first, __last, __comp);
}
regards,
George
"Anthony Wieser" wrote:
Nth element can be implemented in linear time using a modified
version
of
quicksort's partition phase.
Anthony Wieser
Wieser Software Ltd