Пример 1. Быстрая сортировка Хоара на C.

void quickSort (int a[], int l, int r)
{
    int i = l;
    int j = r;
    int x = a[(l + r) / 2];
    do
    {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i <= j)
        {
            int temp = a[i];
            a[i++] = a[j];
            a[j--] = temp;
        }
    }
    while (i <= j);
    if (l < j) quickSort (a, l, j);
    if (i < r) quickSort (a, i, r);
}

Пример 2. Быстрая сортировка Хоара на абстрактном функциональном языке.

quickSort ([]) = []
quickSort ([h : t]) = quickSort (n | n ∈ t, n <= h) + [h] + quickSort (n | n ∈ t, n > h)

Пример 2 следует читать так:
1. Если список пуст, то результатом также будет пустой список.

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

Пример 3. Быстрая сортировка Хоара на языке Haskell.

quickSort [] = []
quickSort (h : t) = quickSort [y | y <- t, y < h] ++ [h] ++ quickSort [y | y <- t, y >= h]

Как видно, даже на таком простом примере функциональный стиль программирования выигрывает и по количеству написанного кода и по его элегантности.

M>void quickSort (int a[], int l, int r)
M>{
M>    int i = l;
M>    int j = r;
M>    int x = a[(l + r) / 2];
M>    do
M>    {
M>        while (a[i] < x) i++;
M>        while (x < a[j]) j--;
M>        if (i <= j)
M>        {
M>            int temp = a[i];
M>            a[i++] = a[j];
M>            a[j--] = temp;
M>        }
M>    }
M>    while (i <= j);
M>    if (l < j) quickSort (a, l, j);
M>    if (i < r) quickSort (a, i, r);
M>}
M>

//от работы с элементами списка перешли к работе 
// с индексами (хотя в описании алгоритма про индексы ни слова)
int i = l; int j = r; 

// да это же обмен значениями! ну и конечно очевидно, 
// что вместе с обменом значениями передвигаются и указатели 
int temp = a[i]; a[i++] = a[j]; a[j--] = temp; на элементы (индексы)

// легко! поиск элемента (<x)
while (a[i] < x) i++;

// легко! поиск элемента (>x) 
while (x < a[j]) j--;

// а точно! мы же просматриваем массив сразу с двух сторон, 
// а это условие завершения
do ... while (i <= j);

M>quickSort [] = []
M>quickSort (h : t) = quickSort [y | y <- t, y < h] ++ [h] ++ quickSort [y | y <- t, y >= h]
M>

quickSort (x:xs) = quickSort [y | y <- xs, y < x] ++ [x] ++ quickSort [y | y <- xs, y >= x]

foreach(элем1:список1)
  foreach(элем2:список2)
    ..
    if (условие1 и условие2 и ...)
      посчитать что_хотим_получить и включить это значение в результат
    end
  end
end

qsort (x:xs) = qsort lesser ++ [x] ++ qsort greater
  where lesser  = filter (<x) xs
        greater = filter (>=x) xs

void quickSort (int a[], int l, int r)
{
        // Вопрос: мы работаем с полуоткрытым интервалом или с закрытым? [l..r) или [l..r] ?
        // Ладно, обозначим правую границу загадочным }
        
    int i = l;
    int j = r;
    int x = a[(l + r) / 2];
    // почему в роли медианы взяли значение из середины массива?
    // при каких условиях здесь произойдёт вылет за границы?
    
    // инвариант цикла: a[l..i} < x < [j..r}
    // на каждой итерации диапазон [i..j} сужается
    // постусловие - a[i..j} == x (причём очевидно, что этот интервал не пуст, ведь ему принадлежит медиана)
    do
    {
        while (a[i] < x) i++; // кажется, всё-таки работаем с закрытыми интервалами
        while (x < a[j]) j--;
        
        // замечательный сплав swap() и автоинкрементов, очень "интуитивно"
        if (i <= j)
        {
            int temp = a[i];
            a[i++] = a[j];
            a[j--] = temp;
        }
    }
    while (i <= j); // Зачем проверку диапазона делаем только после первой итерации? Она что, раньше нам не нужна?
    
    if (l < j) quickSort (a, l, j);
    if (i < r) quickSort (a, i, r);
}