O（n）の長さnのソートされていない配列でk番目に大きい要素を見つける方法は？
O（n）の長さnのソートされていない配列でk番目に大きい要素を見つける方法があると思います。または、おそらく「予想される」O(n)または何かです。どうすればこれができますか？
これは、k次統計量の検索と呼ばれます。非常に単純なランダム化アルゴリズム（quickselectと呼ばれる）があり、O(n)平均時間、O(n^2)最悪のケース時間、およびかなり複雑な非ランダム化アルゴリズム（introselectと呼ばれます） ）O(n)最悪の場合の時間。 Wikipedia にはいくつかの情報がありますが、あまり良くありません。
必要なものはすべて これらのPowerPointスライド にあります。 O(n)ワーストケースアルゴリズム（introselect）の基本アルゴリズムを抽出するだけです。
Select(A,n,i):
Divide input into ⌈n/5⌉ groups of size 5.
/* Partition on median-of-medians */
medians = array of each group’s median.
pivot = Select(medians, ⌈n/5⌉, ⌈n/10⌉)
Left Array L and Right Array G = partition(A, pivot)
/* Find ith element in L, pivot, or G */
k = |L| + 1
If i = k, return pivot
If i < k, return Select(L, k-1, i)
If i > k, return Select(G, n-k, i-k)
また、Cormen et al。の「アルゴリズムの概要」の本でも非常に詳しく説明されています。
O(n)やそのようなものとは対照的に、真のO(kn)アルゴリズムが必要な場合は、quickselectを使用する必要があります（基本的には、興味のないパーティションを捨てるクイックソートです）。私の教授は、ランタイム分析で素晴らしい記事を書いています：（ reference ）
QuickSelectアルゴリズムは、n要素のソートされていない配列のk番目に小さい要素をすばやく見つけます。これは RandomizedAlgorithm であるため、最悪の場合expectedの実行時間を計算します。
これがアルゴリズムです。
QuickSelect(A, k)
let r be chosen uniformly at random in the range 1 to length(A)
let pivot = A[r]
let A1, A2 be new arrays
# split into a pile A1 of small elements and A2 of big elements
for i = 1 to n
if A[i] < pivot then
append A[i] to A1
else if A[i] > pivot then
append A[i] to A2
else
# do nothing
end for
if k <= length(A1):
# it's in the pile of small elements
return QuickSelect(A1, k)
else if k > length(A) - length(A2)
# it's in the pile of big elements
return QuickSelect(A2, k - (length(A) - length(A2))
else
# it's equal to the pivot
return pivot
このアルゴリズムの実行時間は？敵がコインを裏返した場合、ピボットは常に最大の要素であり、kは常に1であり、実行時間は
T(n) = Theta(n) + T(n-1) = Theta(n2)しかし、選択肢が実際にランダムである場合、予想される実行時間は
T(n) <= Theta(n) + (1/n) ∑i=1 to nT(max(i, n-i-1))ここで、再帰は常にA1またはA2の大きい方に到達するという完全に合理的な仮定ではありません。
いくつかのaのT(n) <= anを推測しましょう。それから
T(n)
<= cn + (1/n) ∑i=1 to nT(max(i-1, n-i))
= cn + (1/n) ∑i=1 to floor(n/2) T(n-i) + (1/n) ∑i=floor(n/2)+1 to n T(i)
<= cn + 2 (1/n) ∑i=floor(n/2) to n T(i)
<= cn + 2 (1/n) ∑i=floor(n/2) to n aiそして、今度は、左側のcnを吸収するために、プラス記号の右側にある恐ろしい合計を取得する必要があります。単に2(1/n) ∑i=n/2 to n anとしてバインドすると、おおよそ2(1/n)(n/2)an = anになります。しかし、これは大きすぎます-余分なcnを絞る余地はありません。それでは、算術級数式を使用して合計を展開しましょう
∑i=floor(n/2) to n i
= ∑i=1 to n i - ∑i=1 to floor(n/2) i
= n(n+1)/2 - floor(n/2)(floor(n/2)+1)/2
<= n2/2 - (n/4)2/2
= (15/32)n2ここで、nが「十分に大きい」ことを利用して、いfloor(n/2)ファクターを、よりクリーンな（そしてより小さい）n/4に置き換えます。これで続行できます
cn + 2 (1/n) ∑i=floor(n/2) to n ai,
<= cn + (2a/n) (15/32) n2
= n (c + (15/16)a)
<= ana > 16cを提供。
これにより、T(n) = O(n)が得られます。明らかにOmega(n)なので、T(n) = Theta(n)を取得します。
簡単なGoogle（「k番目に大きい要素配列」）がこれを返しました： http://discuss.joelonsoftware.com/default.asp?interview.11.509587.17
"Make one pass through tracking the three largest values so far."
（特に3D最大のものでした）
そしてこの答え：
Build a heap/priority queue. O(n)
Pop top element. O(log n)
Pop top element. O(log n)
Pop top element. O(log n)
Total = O(n) + 3 O(log n) = O(n)
あなたはクイックソートが好きです。ランダムに要素を選択し、すべてを高くまたは低く押します。この時点で、実際に選択した要素がわかります。k番目の要素であれば、k番目の要素が含まれることをビン（高または低）で繰り返します。統計的に言えば、時間k番目の要素がn、O（n）とともに成長するのを見つけるのに必要です。
アルゴリズム分析のプログラマのコンパニオン は、isO（n）のバージョンを提供しますが、著者は定数因子は非常に高いので、おそらく単純なリストを選択してから選択する方法を好むでしょう。
私はあなたの質問の手紙に答えました:)
C++標準ライブラリには、ほぼ正確に function call nth_elementがありますが、データは変更されます。線形実行時間O（N）を予期しており、部分的なソートも行います。
const int N = ...;
double a[N];
// ...
const int m = ...; // m < N
nth_element (a, a + m, a + N);
// a[m] contains the mth element in a
O(n)の複雑さについてはあまりわかりませんが、O(n)とnLog（n）の間にあることは確実です。 to O(n) to nLog（n）。関数はJavaで記述されています
public int quickSelect(ArrayList<Integer>list, int nthSmallest){
//Choose random number in range of 0 to array length
Random random = new Random();
//This will give random number which is not greater than length - 1
int pivotIndex = random.nextInt(list.size() - 1);
int pivot = list.get(pivotIndex);
ArrayList<Integer> smallerNumberList = new ArrayList<Integer>();
ArrayList<Integer> greaterNumberList = new ArrayList<Integer>();
//Split list into two.
//Value smaller than pivot should go to smallerNumberList
//Value greater than pivot should go to greaterNumberList
//Do nothing for value which is equal to pivot
for(int i=0; i<list.size(); i++){
if(list.get(i)<pivot){
smallerNumberList.add(list.get(i));
}
else if(list.get(i)>pivot){
greaterNumberList.add(list.get(i));
}
else{
//Do nothing
}
}
//If smallerNumberList size is greater than nthSmallest value, nthSmallest number must be in this list
if(nthSmallest < smallerNumberList.size()){
return quickSelect(smallerNumberList, nthSmallest);
}
//If nthSmallest is greater than [ list.size() - greaterNumberList.size() ], nthSmallest number must be in this list
//The step is bit tricky. If confusing, please see the above loop once again for clarification.
else if(nthSmallest > (list.size() - greaterNumberList.size())){
//nthSmallest will have to be changed here. [ list.size() - greaterNumberList.size() ] elements are already in
//smallerNumberList
nthSmallest = nthSmallest - (list.size() - greaterNumberList.size());
return quickSelect(greaterNumberList,nthSmallest);
}
else{
return pivot;
}
}
動的プログラミング、特にトーナメント方式を使用して、ソートされていないn個の要素でk番目の最小値を見つけることを実装しました。実行時間はO（n + klog（n））です。使用されているメカニズムは、選択アルゴリズムに関するウィキペディアのページのメソッドの1つとしてリストされています（上記の投稿の1つで示されています）。アルゴリズムについて読むこともできますし、私のブログページでコード（Java）を見つけることもできます Kth Minimumを見つける 。さらに、ロジックはリストの部分的な順序付けを行うことができます-O(klog(n))時間で最初のK min（またはmax）を返します。
コードはk番目の最小結果を提供しましたが、同様のロジックを使用してO（klog（n））のk番目の最大値を見つけ、トーナメントツリーを作成するための事前作業を無視できます。
Pythonのセクシーなクイック選択
def quickselect(arr, k):
'''
k = 1 returns first element in ascending order.
can be easily modified to return first element in descending order
'''
r = random.randrange(0, len(arr))
a1 = [i for i in arr if i < arr[r]] '''partition'''
a2 = [i for i in arr if i > arr[r]]
if k <= len(a1):
return quickselect(a1, k)
Elif k > len(arr)-len(a2):
return quickselect(a2, k - (len(arr) - len(a2)))
else:
return arr[r]
Kを最大に追跡することにより、時間に対してO（n + kn）= O(n)（定数k）およびスペースに対してO(k)でそれを行うことができます。あなたが見た要素。
配列内の各要素について、k個の最大のリストをスキャンし、最小の要素が大きい場合は新しい要素に置き換えることができます。
ただし、Warrenの優先ヒープソリューションはすっきりしています。
以下は、完全な実装へのリンクであり、ソートされていないアルゴリズムでK番目の要素を見つけるためのアルゴリズムがどのように機能するかについての非常に広範な説明があります。基本的な考え方は、QuickSortのように配列を分割することです。しかし、極端な場合（たとえば、アルゴリズムがO（n ^ 2）実行時間に縮退するようにすべてのステップで最小要素がピボットとして選択される場合）を回避するために、中央値アルゴリズムと呼ばれる特別なピボット選択が適用されます。ソリューション全体は、最悪の場合および平均的な場合にO(n)時間で実行されます。
ここに記事全体へのリンクがあります（Kthsmallest要素を見つけることについてですが、Kthlargestを見つける原理は同じです）：
このちょっとしたアプローチはどうですか
buffer of length kとtmp_maxを維持し、tmp_maxを取得することはO(k)であり、n回実行されるため、O(kn)のようなものです。
それは正しいですか、何か不足していますか？
クイック選択の平均的なケースやメディアン統計法の最悪のケースに勝るものではありませんが、理解と実装は非常に簡単です
線形時間で配列の中央値を見つけてから、クイックソートの場合とまったく同じパーティション手順を使用して、中央値より左側の値（中央値よりも小さい（<）および中央値よりも大きい値（>）の2つの部分に配列を分割します、それも直線的に行うことができます。次に、k番目の要素がある配列のその部分に移動します。Nowの繰り返しは次のようになります。T(n) = T(n/2) + cnは、私にO（n）を与えます。
この論文のとおり n個のアイテムのリストでK番目に大きいアイテムを見つける 次のアルゴリズムは最悪の場合O(n)時間かかります。
- 配列を各5要素のn/5リストに分割します。
- 5要素の各サブ配列の中央値を見つけます。
- すべての中央値の中央値を再帰的に見つけ、それをMと呼びましょう
- 配列を2つのサブ配列に分割します。1番目のサブ配列にはMよりも大きい要素が含まれ、このサブ配列にはa1が含まれ、他のサブ配列にはMよりも小さい要素が含まれます。
- K <= | a1 |の場合、選択（a1、k）を返します。
- K− 1 = | a1 |の場合、Mを返します。
- K> | a1 |の場合+ 1、selection（a2、k −a1 − 1）を返します。
分析：元の論文で示唆されているように：
リストを2つの半分に分割するために中央値を使用します（
k <= n/2の場合は前半、それ以外の場合は後半）。このアルゴリズムは、いくつかの定数cnの再帰の最初のレベルでc、次のレベル（サイズn/2のリストで再帰するため）でcn/2、3番目のレベルでcn/4などのように時間がかかります。合計所要時間はcn + cn/2 + cn/4 + .... = 2cn = o(n)です。
パーティションサイズが3ではなく5になるのはなぜですか？
オリジナル 紙 で述べたように：
リストを5で除算すると、70〜30のワーストケース分割が保証されます。中央値の中央値が中央値の中央値よりも大きいため、n/5ブロックの少なくとも半分には少なくとも3つの要素があり、これにより
3n/10分割が得られます。つまり、最悪の場合、他のパーティションは7n/10です。これにより、T(n) = T(n/5)+T(7n/10)+O(n). Since n/5+7n/10 < 1、最悪の実行時間isO(n)が得られます。
今、私は上記のアルゴリズムを次のように実装しようとしました：
public static int findKthLargestUsingMedian(Integer[] array, int k) {
// Step 1: Divide the list into n/5 lists of 5 element each.
int noOfRequiredLists = (int) Math.ceil(array.length / 5.0);
// Step 2: Find pivotal element aka median of medians.
int medianOfMedian = findMedianOfMedians(array, noOfRequiredLists);
//Now we need two lists split using medianOfMedian as pivot. All elements in list listOne will be grater than medianOfMedian and listTwo will have elements lesser than medianOfMedian.
List<Integer> listWithGreaterNumbers = new ArrayList<>(); // elements greater than medianOfMedian
List<Integer> listWithSmallerNumbers = new ArrayList<>(); // elements less than medianOfMedian
for (Integer element : array) {
if (element < medianOfMedian) {
listWithSmallerNumbers.add(element);
} else if (element > medianOfMedian) {
listWithGreaterNumbers.add(element);
}
}
// Next step.
if (k <= listWithGreaterNumbers.size()) return findKthLargestUsingMedian((Integer[]) listWithGreaterNumbers.toArray(new Integer[listWithGreaterNumbers.size()]), k);
else if ((k - 1) == listWithGreaterNumbers.size()) return medianOfMedian;
else if (k > (listWithGreaterNumbers.size() + 1)) return findKthLargestUsingMedian((Integer[]) listWithSmallerNumbers.toArray(new Integer[listWithSmallerNumbers.size()]), k-listWithGreaterNumbers.size()-1);
return -1;
}
public static int findMedianOfMedians(Integer[] mainList, int noOfRequiredLists) {
int[] medians = new int[noOfRequiredLists];
for (int count = 0; count < noOfRequiredLists; count++) {
int startOfPartialArray = 5 * count;
int endOfPartialArray = startOfPartialArray + 5;
Integer[] partialArray = Arrays.copyOfRange((Integer[]) mainList, startOfPartialArray, endOfPartialArray);
// Step 2: Find median of each of these sublists.
int medianIndex = partialArray.length/2;
medians[count] = partialArray[medianIndex];
}
// Step 3: Find median of the medians.
return medians[medians.length / 2];
}
完了のために、別のアルゴリズムは優先度キューを使用し、O(nlogn)の時間がかかります。
public static int findKthLargestUsingPriorityQueue(Integer[] nums, int k) {
int p = 0;
int numElements = nums.length;
// create priority queue where all the elements of nums will be stored
PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
// place all the elements of the array to this priority queue
for (int n : nums) {
pq.add(n);
}
// extract the kth largest element
while (numElements - k + 1 > 0) {
p = pq.poll();
k++;
}
return p;
}
これらのアルゴリズムは両方とも次のようにテストできます。
public static void main(String[] args) throws IOException {
Integer[] numbers = new Integer[]{2, 3, 5, 4, 1, 12, 11, 13, 16, 7, 8, 6, 10, 9, 17, 15, 19, 20, 18, 23, 21, 22, 25, 24, 14};
System.out.println(findKthLargestUsingMedian(numbers, 8));
System.out.println(findKthLargestUsingPriorityQueue(numbers, 8));
}
予想される出力は次のとおりです。18 18
リストを反復処理します。現在の値が保存されている最大値よりも大きい場合は、最大値として保存し、1〜4を下げて5をリストからドロップします。そうでない場合は、2と比較して同じことを行います。 5つの保存された値すべてに対してチェックを繰り返します。これはO（n）でそれを行う必要があります
Wirthの選択アルゴリズム もあり、QuickSelectよりも実装が簡単です。 Wirthの選択アルゴリズムはQuickSelectよりも低速ですが、いくつかの改善により高速になります。
さらに詳細に。 Vladimir ZabrodskyのMODIFIND最適化と中央値3のピボット選択を使用し、アルゴリズムの分割部分の最終ステップに注意を払って、次のアルゴリズム（「LefSelect」と名付けられた）を思いつきました。
#define F_SWAP(a,b) { float temp=(a);(a)=(b);(b)=temp; }
# Note: The code needs more than 2 elements to work
float lefselect(float a[], const int n, const int k) {
int l=0, m = n-1, i=l, j=m;
float x;
while (l<m) {
if( a[k] < a[i] ) F_SWAP(a[i],a[k]);
if( a[j] < a[i] ) F_SWAP(a[i],a[j]);
if( a[j] < a[k] ) F_SWAP(a[k],a[j]);
x=a[k];
while (j>k & i<k) {
do i++; while (a[i]<x);
do j--; while (a[j]>x);
F_SWAP(a[i],a[j]);
}
i++; j--;
if (j<k) {
while (a[i]<x) i++;
l=i; j=m;
}
if (k<i) {
while (x<a[j]) j--;
m=j; i=l;
}
}
return a[k];
}
here で行ったベンチマークでは、LefSelectはQuickSelectより20-30％高速です。
Randomized QuickSelectのC++実装を次に示します。アイデアは、ピボット要素をランダムに選択することです。ランダム化されたパーティションを実装するには、ランダム関数Rand（）を使用してlとrの間のインデックスを生成し、ランダムに生成されたインデックスの要素を最後の要素と交換し、最後に最後の要素をピボットとして使用する標準パーティションプロセスを呼び出します。
#include<iostream>
#include<climits>
#include<cstdlib>
using namespace std;
int randomPartition(int arr[], int l, int r);
// This function returns k'th smallest element in arr[l..r] using
// QuickSort based method. ASSUMPTION: ALL ELEMENTS IN ARR[] ARE DISTINCT
int kthSmallest(int arr[], int l, int r, int k)
{
// If k is smaller than number of elements in array
if (k > 0 && k <= r - l + 1)
{
// Partition the array around a random element and
// get position of pivot element in sorted array
int pos = randomPartition(arr, l, r);
// If position is same as k
if (pos-l == k-1)
return arr[pos];
if (pos-l > k-1) // If position is more, recur for left subarray
return kthSmallest(arr, l, pos-1, k);
// Else recur for right subarray
return kthSmallest(arr, pos+1, r, k-pos+l-1);
}
// If k is more than number of elements in array
return INT_MAX;
}
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
// Standard partition process of QuickSort(). It considers the last
// element as pivot and moves all smaller element to left of it and
// greater elements to right. This function is used by randomPartition()
int partition(int arr[], int l, int r)
{
int x = arr[r], i = l;
for (int j = l; j <= r - 1; j++)
{
if (arr[j] <= x) //arr[i] is bigger than arr[j] so swap them
{
swap(&arr[i], &arr[j]);
i++;
}
}
swap(&arr[i], &arr[r]); // swap the pivot
return i;
}
// Picks a random pivot element between l and r and partitions
// arr[l..r] around the randomly picked element using partition()
int randomPartition(int arr[], int l, int r)
{
int n = r-l+1;
int pivot = Rand() % n;
swap(&arr[l + pivot], &arr[r]);
return partition(arr, l, r);
}
// Driver program to test above methods
int main()
{
int arr[] = {12, 3, 5, 7, 4, 19, 26};
int n = sizeof(arr)/sizeof(arr[0]), k = 3;
cout << "K'th smallest element is " << kthSmallest(arr, 0, n-1, k);
return 0;
}
上記のソリューションの最悪の場合の時間の複雑さは、依然としてO（n2）です。最悪の場合、ランダム化された関数は常にコーナー要素を選択します。上記のランダム化されたQuickSelectの予想される時間の複雑さはΘ（n）です
Nからk番目に大きい整数を見つけるメディアンアルゴリズムの説明は、ここにあります： http://cs.indstate.edu/~spitla/presentation.pdf
C++での実装は次のとおりです。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int findMedian(vector<int> vec){
// Find median of a vector
int median;
size_t size = vec.size();
median = vec[(size/2)];
return median;
}
int findMedianOfMedians(vector<vector<int> > values){
vector<int> medians;
for (int i = 0; i < values.size(); i++) {
int m = findMedian(values[i]);
medians.Push_back(m);
}
return findMedian(medians);
}
void selectionByMedianOfMedians(const vector<int> values, int k){
// Divide the list into n/5 lists of 5 elements each
vector<vector<int> > vec2D;
int count = 0;
while (count != values.size()) {
int countRow = 0;
vector<int> row;
while ((countRow < 5) && (count < values.size())) {
row.Push_back(values[count]);
count++;
countRow++;
}
vec2D.Push_back(row);
}
cout<<endl<<endl<<"Printing 2D vector : "<<endl;
for (int i = 0; i < vec2D.size(); i++) {
for (int j = 0; j < vec2D[i].size(); j++) {
cout<<vec2D[i][j]<<" ";
}
cout<<endl;
}
cout<<endl;
// Calculating a new pivot for making splits
int m = findMedianOfMedians(vec2D);
cout<<"Median of medians is : "<<m<<endl;
// Partition the list into unique elements larger than 'm' (call this sublist L1) and
// those smaller them 'm' (call this sublist L2)
vector<int> L1, L2;
for (int i = 0; i < vec2D.size(); i++) {
for (int j = 0; j < vec2D[i].size(); j++) {
if (vec2D[i][j] > m) {
L1.Push_back(vec2D[i][j]);
}else if (vec2D[i][j] < m){
L2.Push_back(vec2D[i][j]);
}
}
}
// Checking the splits as per the new pivot 'm'
cout<<endl<<"Printing L1 : "<<endl;
for (int i = 0; i < L1.size(); i++) {
cout<<L1[i]<<" ";
}
cout<<endl<<endl<<"Printing L2 : "<<endl;
for (int i = 0; i < L2.size(); i++) {
cout<<L2[i]<<" ";
}
// Recursive calls
if ((k - 1) == L1.size()) {
cout<<endl<<endl<<"Answer :"<<m;
}else if (k <= L1.size()) {
return selectionByMedianOfMedians(L1, k);
}else if (k > (L1.size() + 1)){
return selectionByMedianOfMedians(L2, k-((int)L1.size())-1);
}
}
int main()
{
int values[] = {2, 3, 5, 4, 1, 12, 11, 13, 16, 7, 8, 6, 10, 9, 17, 15, 19, 20, 18, 23, 21, 22, 25, 24, 14};
vector<int> vec(values, values + 25);
cout<<"The given array is : "<<endl;
for (int i = 0; i < vec.size(); i++) {
cout<<vec[i]<<" ";
}
selectionByMedianOfMedians(vec, 8);
return 0;
}
Haskellソリューション：
kthElem index list = sort list !! index
withShape ~[] [] = []
withShape ~(x:xs) (y:ys) = x : withShape xs ys
sort [] = []
sort (x:xs) = (sort ls `withShape` ls) ++ [x] ++ (sort rs `withShape` rs)
where
ls = filter (< x)
rs = filter (>= x)
これは、withShapeメソッドを使用して実際に計算せずにパーティションのサイズを検出することにより、中央値ソリューションの中央値を実装します。
- 優先度キューを作成します。
- すべての要素をヒープに挿入します。
Poll（）をk回呼び出します。
public static int getKthLargestElements(int[] arr) { PriorityQueue<Integer> pq = new PriorityQueue<>((x , y) -> (y-x)); //insert all the elements into heap for(int ele : arr) pq.offer(ele); // call poll() k times int i=0; while(i<k) { int result = pq.poll(); } return result; }
私は1つの答えを提案したいと思います
最初のk個の要素を取得して、それらをk個の値のリンクリストに並べ替える場合
最悪の場合でも残りのnk値の挿入ソートを行う場合、他のすべての値については、比較の数はk *（nk）になり、前のk値をソートするにはk *（k- 1）したがって、o（n）である（nk-k）になる
乾杯
私はこのアルゴリズムを思いつき、O（n）のようです：
K = 3とし、配列内で3番目に大きい項目を見つけたいとします。 3つの変数を作成し、配列の各項目をこれら3つの変数の最小値と比較します。配列項目が最小値よりも大きい場合、min変数を項目値に置き換えます。配列の最後まで同じことを続けます。 3つの変数の最小値は、配列の3番目に大きい項目です。
define variables a=0, b=0, c=0
iterate through the array items
find minimum a,b,c
if item > min then replace the min variable with item value
continue until end of array
the minimum of a,b,c is our answer
そして、K番目に大きいアイテムを見つけるには、K個の変数が必要です。
例：（k = 3）
[1,2,4,1,7,3,9,5,6,2,9,8]
Final variable values:
a=7 (answer)
b=8
c=9
誰かがこれを確認して、私が行方不明になっているものを教えてもらえますか？
このリンクの最後に移動します：...........
Eladvが推奨するアルゴリズムの実装を次に示します（ランダムピボットを使用した実装もここに記載します）。
public class Median {
public static void main(String[] s) {
int[] test = {4,18,20,3,7,13,5,8,2,1,15,17,25,30,16};
System.out.println(selectK(test,8));
/*
int n = 100000000;
int[] test = new int[n];
for(int i=0; i<test.length; i++)
test[i] = (int)(Math.random()*test.length);
long start = System.currentTimeMillis();
random_selectK(test, test.length/2);
long end = System.currentTimeMillis();
System.out.println(end - start);
*/
}
public static int random_selectK(int[] a, int k) {
if(a.length <= 1)
return a[0];
int r = (int)(Math.random() * a.length);
int p = a[r];
int small = 0, equal = 0, big = 0;
for(int i=0; i<a.length; i++) {
if(a[i] < p) small++;
else if(a[i] == p) equal++;
else if(a[i] > p) big++;
}
if(k <= small) {
int[] temp = new int[small];
for(int i=0, j=0; i<a.length; i++)
if(a[i] < p)
temp[j++] = a[i];
return random_selectK(temp, k);
}
else if (k <= small+equal)
return p;
else {
int[] temp = new int[big];
for(int i=0, j=0; i<a.length; i++)
if(a[i] > p)
temp[j++] = a[i];
return random_selectK(temp,k-small-equal);
}
}
public static int selectK(int[] a, int k) {
if(a.length <= 5) {
Arrays.sort(a);
return a[k-1];
}
int p = median_of_medians(a);
int small = 0, equal = 0, big = 0;
for(int i=0; i<a.length; i++) {
if(a[i] < p) small++;
else if(a[i] == p) equal++;
else if(a[i] > p) big++;
}
if(k <= small) {
int[] temp = new int[small];
for(int i=0, j=0; i<a.length; i++)
if(a[i] < p)
temp[j++] = a[i];
return selectK(temp, k);
}
else if (k <= small+equal)
return p;
else {
int[] temp = new int[big];
for(int i=0, j=0; i<a.length; i++)
if(a[i] > p)
temp[j++] = a[i];
return selectK(temp,k-small-equal);
}
}
private static int median_of_medians(int[] a) {
int[] b = new int[a.length/5];
int[] temp = new int[5];
for(int i=0; i<b.length; i++) {
for(int j=0; j<5; j++)
temp[j] = a[5*i + j];
Arrays.sort(temp);
b[i] = temp[2];
}
return selectK(b, b.length/2 + 1);
}
}
O(n)時間および定数空間でk番目に小さい要素を見つけることができます。配列が整数専用であると考えると。
アプローチは、配列値の範囲でバイナリ検索を行うことです。 min_valueとmax_valueの両方が整数範囲にある場合、その範囲でバイナリ検索を実行できます。いずれかの値がkth-smallestより小さいか、kth-smallestより小さいか、kth-smallestより大きいかを示すコンパレーター関数を作成できます。 k番目に小さい数に達するまでバイナリ検索を実行します
以下がそのためのコードです
クラスソリューション：
def _iskthsmallest(self, A, val, k):
less_count, equal_count = 0, 0
for i in range(len(A)):
if A[i] == val: equal_count += 1
if A[i] < val: less_count += 1
if less_count >= k: return 1
if less_count + equal_count < k: return -1
return 0
def kthsmallest_binary(self, A, min_val, max_val, k):
if min_val == max_val:
return min_val
mid = (min_val + max_val)/2
iskthsmallest = self._iskthsmallest(A, mid, k)
if iskthsmallest == 0: return mid
if iskthsmallest > 0: return self.kthsmallest_binary(A, min_val, mid, k)
return self.kthsmallest_binary(A, mid+1, max_val, k)
# @param A : Tuple of integers
# @param B : integer
# @return an integer
def kthsmallest(self, A, k):
if not A: return 0
if k > len(A): return 0
min_val, max_val = min(A), max(A)
return self.kthsmallest_binary(A, min_val, max_val, k)
また、quickselectアルゴリズムよりも優れたアルゴリズムが1つあります。それはFloyd-Rivets（FR）アルゴリズムと呼ばれます。
元の記事： https://doi.org/10.1145/360680.360694
ダウンロード可能なバージョン： http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.309.7108&rep=rep1&type=pdf
ウィキペディアの記事 https://en.wikipedia.org/wiki/Floyd%E2%80%93Rivest_algorithm
QuickselectとFRアルゴリズムをC++で実装しようとしました。また、標準のC++ライブラリ実装std :: nth_element（基本的には、クイック選択とヒープ選択のイントロセレクトハイブリッド）と比較しました。結果はquickselectであり、nth_elementは平均して同等に実行されましたが、FRアルゴリズムはおよそ実行されました。それらに比べて2倍高速です。
FRアルゴリズムに使用したサンプルコード：
template <typename T>
T FRselect(std::vector<T>& data, const size_t& n)
{
if (n == 0)
return *(std::min_element(data.begin(), data.end()));
else if (n == data.size() - 1)
return *(std::max_element(data.begin(), data.end()));
else
return _FRselect(data, 0, data.size() - 1, n);
}
template <typename T>
T _FRselect(std::vector<T>& data, const size_t& left, const size_t& right, const size_t& n)
{
size_t leftIdx = left;
size_t rightIdx = right;
while (rightIdx > leftIdx)
{
if (rightIdx - leftIdx > 600)
{
size_t range = rightIdx - leftIdx + 1;
long long i = n - (long long)leftIdx + 1;
long long z = log(range);
long long s = 0.5 * exp(2 * z / 3);
long long sd = 0.5 * sqrt(z * s * (range - s) / range) * sgn(i - (long long)range / 2);
size_t newLeft = fmax(leftIdx, n - i * s / range + sd);
size_t newRight = fmin(rightIdx, n + (range - i) * s / range + sd);
_FRselect(data, newLeft, newRight, n);
}
T t = data[n];
size_t i = leftIdx;
size_t j = rightIdx;
// arrange pivot and right index
std::swap(data[leftIdx], data[n]);
if (data[rightIdx] > t)
std::swap(data[rightIdx], data[leftIdx]);
while (i < j)
{
std::swap(data[i], data[j]);
++i; --j;
while (data[i] < t) ++i;
while (data[j] > t) --j;
}
if (data[leftIdx] == t)
std::swap(data[leftIdx], data[j]);
else
{
++j;
std::swap(data[j], data[rightIdx]);
}
// adjust left and right towards the boundaries of the subset
// containing the (k - left + 1)th smallest element
if (j <= n)
leftIdx = j + 1;
if (n <= j)
rightIdx = j - 1;
}
return data[leftIdx];
}
template <typename T>
int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
これは、任意のピボットを選択し、小さな要素を左に、大きな要素を右に移動するquickSort戦略に似ています
public static int kthElInUnsortedList(List<int> list, int k)
{
if (list.Count == 1)
return list[0];
List<int> left = new List<int>();
List<int> right = new List<int>();
int pivotIndex = list.Count / 2;
int pivot = list[pivotIndex]; //arbitrary
for (int i = 0; i < list.Count && i != pivotIndex; i++)
{
int currentEl = list[i];
if (currentEl < pivot)
left.Add(currentEl);
else
right.Add(currentEl);
}
if (k == left.Count + 1)
return pivot;
if (left.Count < k)
return kthElInUnsortedList(right, k - left.Count - 1);
else
return kthElInUnsortedList(left, k);
}
これはJavascriptの実装です。
配列を変更できないという制約を解除すると、2つのインデックスを使用して「現在のパーティション」を特定する余分なメモリの使用を防ぐことができます（従来のクイックソートスタイル- http://www.nczonline.net/ blog/2012/11/27/computer-science-in-javascript-quicksort / ）。
function kthMax(a, k){
var size = a.length;
var pivot = a[ parseInt(Math.random()*size) ]; //Another choice could have been (size / 2)
//Create an array with all element lower than the pivot and an array with all element higher than the pivot
var i, lowerArray = [], upperArray = [];
for (i = 0; i < size; i++){
var current = a[i];
if (current < pivot) {
lowerArray.Push(current);
} else if (current > pivot) {
upperArray.Push(current);
}
}
//Which one should I continue with?
if(k <= upperArray.length) {
//Upper
return kthMax(upperArray, k);
} else {
var newK = k - (size - lowerArray.length);
if (newK > 0) {
///Lower
return kthMax(lowerArray, newK);
} else {
//None ... it's the current pivot!
return pivot;
}
}
}
パフォーマンスをテストする場合は、次のバリエーションを使用できます。
function kthMax (a, k, logging) {
var comparisonCount = 0; //Number of comparison that the algorithm uses
var memoryCount = 0; //Number of integers in memory that the algorithm uses
var _log = logging;
if(k < 0 || k >= a.length) {
if (_log) console.log ("k is out of range");
return false;
}
function _kthmax(a, k){
var size = a.length;
var pivot = a[parseInt(Math.random()*size)];
if(_log) console.log("Inputs:", a, "size="+size, "k="+k, "pivot="+pivot);
// This should never happen. Just a Nice check in this exercise
// if you are playing with the code to avoid never ending recursion
if(typeof pivot === "undefined") {
if (_log) console.log ("Ops...");
return false;
}
var i, lowerArray = [], upperArray = [];
for (i = 0; i < size; i++){
var current = a[i];
if (current < pivot) {
comparisonCount += 1;
memoryCount++;
lowerArray.Push(current);
} else if (current > pivot) {
comparisonCount += 2;
memoryCount++;
upperArray.Push(current);
}
}
if(_log) console.log("Pivoting:",lowerArray, "*"+pivot+"*", upperArray);
if(k <= upperArray.length) {
comparisonCount += 1;
return _kthmax(upperArray, k);
} else if (k > size - lowerArray.length) {
comparisonCount += 2;
return _kthmax(lowerArray, k - (size - lowerArray.length));
} else {
comparisonCount += 2;
return pivot;
}
/*
* BTW, this is the logic for kthMin if we want to implement that... ;-)
*
if(k <= lowerArray.length) {
return kthMin(lowerArray, k);
} else if (k > size - upperArray.length) {
return kthMin(upperArray, k - (size - upperArray.length));
} else
return pivot;
*/
}
var result = _kthmax(a, k);
return {result: result, iterations: comparisonCount, memory: memoryCount};
}
残りのコードは、単に遊び場を作成するためのものです。
function getRandomArray (n){
var ar = [];
for (var i = 0, l = n; i < l; i++) {
ar.Push(Math.round(Math.random() * l))
}
return ar;
}
//Create a random array of 50 numbers
var ar = getRandomArray (50);
ここで、テストを数回実行します。 Math.random（）により、毎回異なる結果が生成されます。
kthMax(ar, 2, true);
kthMax(ar, 2);
kthMax(ar, 2);
kthMax(ar, 2);
kthMax(ar, 2);
kthMax(ar, 2);
kthMax(ar, 34, true);
kthMax(ar, 34);
kthMax(ar, 34);
kthMax(ar, 34);
kthMax(ar, 34);
kthMax(ar, 34);
数回テストすると、平均して、反復回数がO(n)〜=定数* nであり、kの値がアルゴリズムに影響を与えないことが経験的にわかります。