Given is:
N.Find an algorithm that:
K-th smallest array element.N log N) and a space complexity of O(log N).Treat the problem as something analogous to Quicksort. Given an element in the array, you can get its rank in O(n) time and O(lg n) space. You can use binary search to find an element with a given rank in O(lg n) iterations of that, for a total of O(lg n) space and O(n lg n) time.
lo and hi) and their ranks (lo_rank and hi_rank). Label A: Then, pick some element m between lo and hi (in O(n) time) and compute its rank m_rank (in O(n)). If m_rank == k, we are done. If m_rank < k, replace lo and lo_rank with m and m_rank respectively and go to A; if m_rank > k, do the same with hi and go to A.minimum and maximum element.pivot between minimum and maximum (exclusive).pivot (numSmallerEqual) and the number of elements greater than pivot (numBigger).
numSmallerEqual, set maximum=pivot.minimum=pivot.maximum - minimum)==0, output minimum, terminate.maximum - minimum)==1
numSmallerEqual, output minimum.maximum.EDIT: Corrected the error pointed out by lVlad, still not tested.
1 3, k = 2. pivot = 2, minimum = 1, maximum = 3, numSmallerEqual = 1, minimum = 2. pivot = 2, numSmallerEqual = 1, minimum = 2 ... infinite loop.O(n log v), where v is the difference between the maximum and minimum values of the array, not O(n log n). v can be independent of n.Don't construct partitions. Describe what the partitions are (in constant space), and recursively select on this.
Each subarray that quickselect recurses into can be described by its bounds (min and max element values, not their indexes). Iterating over a subarray so described requires O(n) comparisons, which are made at every recursion level, up to the same depth as in quicksort: O(log n) in the average case.
Quicksort also makes O(n) comparisons at every recursion level, while ordinary permuting quickselect makes O(n) comparisons in total in the average case (because it always recurses into only one partition).
Here's a sample implementation for distinct elements with an ordinary quickselect implementation for comparison.
lo and hi are element values. I will iterate over all n elements of the original array in each step, but I will ignore those x that don't satisfy lo ≤ x ≤ hi.You can take the parameterization approach:
Since we have k specified in the problem, we can treat it as a constant, thus space of O(k log N) should be acceptable.
k partitions of equal length (O(1) time and O(k log N) space to store the partition borders because each key should only require log N space)N) time and O(k log N) space to store the smallest elementsk) time)Since there's room for more cycles in there, there's probably a better way to do it. Also note that this would perform very poorly on an array that is sorted...
