Алгоритм 12.1. Нахождение k-го наименьшего элемента

Вход. Массив элементов Array[i], 1  i  n, принадлежащих множеству, на котором установлен линейный порядок, и целое k, 1  k  n.

Выход. k-й наименьший элемент из массива Array.

Метод. В основе алгоритма лежит рекурсивная процедура, Selection (Выбор) заключающаяся в разбиении всей последовательности по некоторому элементу m на три подпоследовательности S₁, S₂ и S₃ такие, что S₁ содержит все элементы, меньшие m, S₂ – все элементы, равные m, а S₃ – все элементы, бóльшие m. Сосчитав количество элементов, находящееся в S₁ и S₂, можно определить, в какой из последовательностей необходимо далее искать k-й наименьший элемент, и, таким образом, свести задачу к задаче меньшей размерности.

Но чтобы получить линейный алгоритм, надо уметь за линейное время находить разбивающий элемент так, чтобы длина каждой из подпоследовательностей S₁ и S₂ была бы не больше фиксированной доли длины исходной последовательности. Здесь вся хитрость заключается в способе выбора разбивающего элемента m. Последовательность, заданная массивом разбивается на подпоследовательности по пять элементов в каждой. Каждая из подпоследовательностей упорядочивается, и из медиан этих подпоследовательностей составляется новая подпоследовательность M. Ввиду изложенного способа выбора M она содержит только n/5 элементов (x наибольшее целое число, содержащееся в x), и можно найти её медиану в пять раз быстрее, чем у последовательности из n элементов.

Очевидно, что не менее четверти всех элементов последовательности будут меньше или равны m и соответственно не менее четверти всех элементов будут больше или равны m. Вместо разбиения на подпоследовательности по пять элементов можно использовать и другие виды разбиений, но необходимо помнить, что сумма длин двух последовательностей, к которым применяется рекурсивная процедура Selection, должна быть меньше n. Иначе время работы алгоритма не будет линейным.

Основные составляющие программы нахождения k-го наименьшего элемента последовательности с использованием алгоритма 12.1 приведены ниже.

Программа 12.1 Нахождения k-го наименьшего элемента

// Программа использует порядковые статистики для выбора k-го минимального

// элемента в последовательности длины NUM

#include <stdlib.h>

#include <stdio.h>

#include <io.h>

#define NUM 124

int Selection(int array[], unsigned order, unsigned init, unsigned fin);

void main()

{

unsigned order, index;

int result, *array;

// В этом месте должна стоять программа ввода массива array и выбора order

result=Selection(array, order, 0, NUM-1);

if (result==-32767) printf("Error: order вне границ массива \n");

else printf("The %d-й минимальный элемент в массиве is %d\n", order, result);

delete [ ] array;

} // Конец main

int Selection(int array[], unsigned order, unsigned init, unsigned fin)

{// Функция выбора k-го элемента из последовательности, заданной массивом

// array, order=k, массив задаётся своими границами init и fin.

unsigned min, max, num_med, indi, indj;

int *median, mean, temp;

if (fin<init) printf("Неправильное использование: init > fin \n");

if ((init>(order-1))||(fin<(order-1))) return -32767;

if ((fin-init+1)<25)

{

// В этом месте должна стоять функция сортировки короткого массива с числом

// элементов, меньшим 25, находящихся в большом массиве array между

// элементами с номерами init и fin

return (array[order-1]);

} else

{

min=init; max=init+4; indi=0;

// Отведение динамической памяти под массив медиан последовательностей из

// пяти элементов

median=new int[(fin-init+1)/5+1];

// Разбиение на группы по 5 элементов, сортировка элементов в группах и

// нахождение медианы в каждой группе

while (max<=fin)

{

// В этом месте должна стоять функция сортировки короткого массива из пяти

// элементов массива array, имеющих индексы между min и max

median[indi++]=array[min+2];

min+=5; max+=5;

}

num_med=indi;

mean=Selection(median, (num_med>>1)+1, 0, num_med-1); 

delete [ ] median;

// Если разбиение массива array на три части даёт подмассивы, содержащие

// элементы меньшие, равные и бóльшие, чем mean соответственно

indi=init; indj=fin;

while(indi<=indj)

{

while ((array[indj]>=mean)&&(indj>=init)) indj--;

while ((array[indi]<mean)&&(indi<=fin)) indi++;

if (indi<indj)

{

// Поменять местами array[indi] и array[indj]

temp=array[indi]; array[indi++]=array[indj]; array[indj--]=temp;

}

}

if(indi>=order) return Selection(array, order, init, indi-1); 

while (array[indi]==mean) indi++;

for (indj=indi+1; indj<=fin; indj++)

if(array[indj]==mean)

{

array[indj]=array[indi]; array[indi++]=mean;

}

if(indi>=order) return mean;

else return Selection(array, order, indi, fin); 

}

} // Конец Selection

Некоторые пояснения к программе. Если размер входной последовательности относительно мал (не более 25 элементов), то гораздо проще отсортировать данную последовательность, например, методом взбалтывания, и выбрать её k-й элемент.

Основная описанная в алгоритме процедура применяется только в случае наличия достаточно большого количества элементов во входной последовательности. Тогда производится выбор разбивающего элемента как медианы медиан пятёрок элементов, на которые разбивается входная последовательность. Элементы внутри пятёрок сортируются, например, методом взбалтывания, и выбирается средний элемент их пятёрки (медиана). Данные медианы хранятся в динамическом массиве median. После этого к массиву median применяется та же процедура Selection, используемая для нахождения медианы этого массива m, которая и выбирается в качестве разбивающего элемента. Размер массива median равен n/5. После разбиения последовательности на три подпоследовательности S₁ (состоящую из элементов, меньших m), S₂ (состоящую из элементов, равных m) и S₃ (состоящую из элементов, бóльших m), программа определяет в какой их данных подпоследовательностей будет находиться k-й элемент всей последовательности. Если он находится в S₂, то работа заканчивается и программа возвращает результат, равный m. Если же искомый элемент находится в S₁ или S₃, то программа применяет процедуру Selection к соответствующей подпоследовательности. Количество элементов в каждой из подпоследовательностей S₁ и S₃ находится в пределах от n/4 до 3n/4 (убедитесь в этом самостоятельно). Поэтому сумма длин подпоследовательностей, к которым применяется процедура Selection на каждом шаге (массив median и подпоследовательность S₁ или S₃) будет меньше n. Поэтому исходный массив разбивается на пятёрки элементов. Некоторые другие «магические числа» (вместо 5) тоже годятся. Попробуйте найти их самостоятельно.

Теорема 8. Алгоритм 12.1 находит k-й наименьший элемент в n-элементной последовательности за время O(n).

Доказательство. Корректность алгоритма доказывается непосредственной индукцией по n, и эта часть доказательства остаётся в качестве упражнения. Пусть T(n) – время, затрачиваемое на выбор k-го наименьшего элемента из последовательности длины n. Длина последовательности M (median) не больше n/5, и поэтому рекурсивный вызов процедуры Selection(median, n/10, 0, n/5) в строке  для массива median занимает время, не большее T(n/5).

Каждая из последовательностей S₁ и S₃ имеет длину не более 3n/4. Поэтому рекурсивный вызов Selection в строке  или  занимает времени не более T(3n/4). Все остальные операторы тратят не более O(n) времени. Таким образом, для некоторых постоянных c и b

Несложно показать (докажите самостоятельно), что T(n)  20bn удовлетворяет последней системе. 

Теперь целесообразно рассмотреть среднее время, затрачиваемое на выбор k-го наименьшего элемента в последовательности из n элементов. Для дальнейшего рассмотрения этого вопроса потребуется определение транзитивного замыкания.

Определение. Транзитивным замыканием отношения R (см. раздел 2.1) называется такое отношение R⁺, что cR⁺d тогда и только тогда, когда существует последовательность истинных утверждений вида e₁Re₂, e₂Re₃, , e_m–1Re_m, где m2, c=e₁ и d=e_m.

Пусть теперь S={a₁, a₂,a_n} – множество из n различных элементов, а T – дерево решений какого-нибудь алгоритма для нахождения k-го наименьшего элемента в S. Каждый путь p в T определяет такое отношение R_p на S, что a_i R_p a_j, если два различных элемента a_i и a_j сравниваются в некотором узле, лежащем на p, и в результате этого сравнения либо a_i < a_j, либо a_j  a_i. Пусть – транзитивное замыкание отношения R_p. Образно говоря, если a_ia_j, то последовательность сравнений, представленная путём p, выясняет, что a_i < a_j, поскольку никакой элемент не сравнивается сам с собой.

Лемма 2. Если на пути p выясняется, что a_m является k-м наименьшим элементом в S, то для любого im, 1 i  n, либо a_ia_m, либо a_ma_i.

Доказательство. Допустим, что некоторый элемент a_u не связан с a_m соотношением . Докажем, что, поместив a_u либо перед, либо после a_m в линейном порядке, заданном на S, получим противоречие с предположением, что путь p правильно установил, что a_m является k-м наименьшим элементом в S. Пусть S₁ ={a_ja_ja_u} (где подобная запись означает: множество S₁ состоит из элементов a_j, для которых выполняется условие a_ja_u), S₂={a_ja_ua_j}, и в S₃ входят остальные элементы из S. По предположению a_u и входят в a_m.

Если a_j – произвольный элемент в S₁ (соответственно в S₂) и a_ia_j (соответственно a_ja_i), то в силу транзитивности a_i также принадлежит S₁ (соответственно в S₂). Следовательно, можно построить такой линейный порядок R, совместимый с ,что все элементы множества S₁ предшествуют всем элементам из S₃, которые в свою очередь предшествуют всем элементам из S₂.

По предположению элемент a_u не связан отношением ни с одним элементом из S₃. Допустим, что a_u предшествует a_m при линейном порядке R, т.е. a_ua_m. Тогда можно построить новый порядок R, совпадающий с R во всём, кроме того, что a_u следует непосредственно за a_m. Отношение R также совместимо с . Для каждого порядка R и R можно найти различные элементы, удовлетворяющие соответственно R или R. Но a_m не может быть k-м наименьшим элементом в обоих случаях, т.к. в R элементу a_m предшествует на один элемент меньше, чем в R. Поэтому заключаем, что если какой-то элемент из S не связан с a_m отношением , то дерево T не может правильно выбрать k-й наименьший элемент из S. Случай a_ma_u исследуется аналогично. 

Теорема 9. Если T – дерево решений, выбирающее k-й наименьший элемент в множестве S, ║S║=n, то глубина любого листа дерева T не меньше n–1. Следствием данной теоремы будет утверждение, что для нахождения k-го наименьшего элемента в S требуется не меньше n–1 сравнений, как в среднем, так и в худшем случае.

Доказательство. Рассмотрим путь p в T из корня к листу. По лемме 2 либо a_ia_m, либо a_ma_i для каждого im, где a_m – элемент, выбранный в качестве k-го наименьшего. Для элемента a_i im, определим ключевое сравнение как первое сравнение не p, содержащее a_i и такое, что выполнено одно из условий:

1. a_i сравнивается с a_m,

2. a_i сравнивается с a_j, a_i R_p a_j, и a_ja_m,

3. a_i сравнивается с a_j, a_j R_p a_i, и a_ma_j.

Интуитивно ключевое сравнение для a_i – это первое сравнение, из которого можно определить, предшествует элемент a_i элементу a_m или следует за ним.

Понятно, что всякий элемент a_i, кроме a_m, обладает сравнением; иначе не выполнилось бы ни a_ia_m, ни a_ma_i. Далее легко видеть, что ни никакое сравнение не может быть ключевым для обоих сравниваемых элементов. Так как в ключевые сравнения должны вовлекаться n–1 элементов, то длина пути p должна быть не меньше n–1.

Поэтому выбирающий алгоритм 12.1 с точностью до постоянного множителя оптимален в классе деревьев решений. Теперь рассмотрим другой выбирающий алгоритм, который имеет квадратичную сложность в худшем случае, но среднее время работы которого составляет лишь долю времени работы алгоритма 12.1. Данный алгоритм использует стратегию, аналогичную той, что применялась в алгоритме Быстрсорт.