Как мы знаем, в быстрой сортировке вы можете использовать Lomuto-Partition. Я проверил множество ссылок, и почти все они предлагают следующую реализацию:

int L_partition(int *a, int l, int r)
{
    int i, j, p, t;

    p = a[r];
    i = l - 1;

    for(j =l; j <= r-1; j++) {
        if(a[j] <= p) {
            i++;

            t = a[j];
            a[j] = a[i];
            a[i] = t;
        }
    }

    t = a[i+1];
    a[i+1] = a[r];
    a[r] = t;

    return i+1;
}

У меня вопрос: почему i начинается с l-1 и содержит все элементы i + 1 ? Думаю, можно просто начать с l . Я тестирую приведенную ниже программу. И дает тот же результат, что и выше. Это намного проще, чем предыдущий.

int L_partition2(int *a, int l, int r)
{
    int i, j, p, t;

    p = a[r];
    i = l;

    for(j = l; j <= r-1; j++) {
        if(a[j] <= p) {
            t = a[j];
            a[j] = a[i];
            a[i] = t;

            i++;
        }
    }

    t = a[i];
    a[i] = a[r];
    a[r] = t;

    return i;

}
5
deepsky 2 Окт 2013 в 11:24
1
Ваша версия лучше. Это эквивалентно, но имеет больше смысла и легче читается. Я не уверен, почему в книгах все наоборот.
 – 
mrip
2 Окт 2013 в 14:30
Поскольку это очень простой и классический алгоритм, мне интересно, не упустил ли я какой-нибудь момент. Практически все веб-сайты и слайды из курса компьютерных наук колледжей используют первый подход.
 – 
deepsky
2 Окт 2013 в 16:24
1
Это странно. Не имеет большого значения, это тот же алгоритм, но ваш код IMO лучше. Может быть, материал (i-1) (i + 1) появился в каком-то старом тексте, а все остальные просто скопировали его.
 – 
mrip
2 Окт 2013 в 17:06

1 ответ

Лучший ответ

Это точно то же самое, что вы просто меняете использование i.

Обратите внимание, что вы увеличиваете i после свопа, потому что ваш действителен с самого начала, а исходная версия увеличивает его перед свопом. Но важно то, что своп всегда использует один и тот же элемент (в вашей версии и в оригинале).

0
luiso1979 2 Окт 2013 в 13:34