Bubble Sort Explanation

// Это исходный код файла "Sort_T.pas",
// отрефакторенный и подробно закомментированный

// Тут реализован (через одно место) алгоритм сортировки пузырьком

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

// Подробнее https://ru.wikipedia.org/wiki/Сортировка_пузырьком

// Программа srt - sort - сортировка
program srt;
var
  // n - длинна сортируемого массива
  // i, j - переменные циклов и индексы элементов массива
  // p - показатель того, что мы еще не меняли массив в текущем проходе по массиву
  // fin - finished - показатель того, что алгоритм завершен и массив отсортирован
  // sit - situation - номер ситуации, в которой мы оказались
  //                         (подробнее про сами ситуации описано ниже)
  // x - вспомогательная переменная для того, чтоб обменивать элементы массива
  i, j, n: integer;
  p, fin: boolean;
  sit: byte;
  {A: array[1..100] of real;}
  x: real;

type
  Arr = array [1..100] of real;

var
  A: arr;

// Эта процедура заполняет первые n1 элементов массива Ar
// случайными целыми числами от 0 до 999
procedure vvod(n1: integer; var Ar: Arr);
var
  j: byte;
begin
  randomize;
  for j := 1 to n1 do Ar[j] := random(1000);
end;

begin
  // Что-то вроде "введите длину массива", но кодировка улетела
  writeln('‚ўҐ¤ЁвҐ Є®«ЁзҐбвў® н«Ґ¬Ґ­в®ў');
  readln(n);
  vvod(n, A);

  // Изначальные значения переменных
  fin := false;
  p := true;
  i := 1;

  // Сама сортировка
  // Будем проходиться по парам массива и обрабатывать ситуации
  repeat
    // Определим какая у нас ситуация

    // === Ситуация 1 ===
    // мы еще не дошли до конца массива (i <= n-1)
    // и текущий элемент больше следующего (a[i] > a[i+1])
    if (i <= n-1) and (a[i] > a[i+1]) then sit := 1;

    // === Ситуация 2 ===
    // мы еще не дошли до конца массива (i <= n-1)
    // и текущий элемент меньше или равен следующему (a[i] <= a[i+1])
    if (i <= n-1) and (a[i] <= a[i+1]) then sit := 2;

    // === Ситуация 3 ===
    // мы дошли до конца массива (i > n-1)
    // и мы меняли массив на этом проходе (p = false)
    if (i > n-1) and (p = false) then sit := 3;

    // === Ситуация 4 ===
    // мы дошли до конца массива (i > n-1)
    // и мы не меняли массив на этом проходе (p = true)
    if (i > n-1) and (p = true) then sit := 4;

    // В данном случае конец массива - это когда a[i] - последний элемент
    // и элемента a[i+1] уже не существует

    // Тут мы обрабатываем ситуации
    case sit of
      // В ситуации 1 мы должны поменять местами a[i] и a[i+1],
      // пометить, что мы сделали изменение в массиве на этом проходе
      // и перейти к следующей паре
      1: begin
           x := A[i]; A[i] := A[i+1]; a[i+1] := x;
           p := false;
           i := i+1
         end;

      // В ситуации 2 мы должны просто перейти к следущюей паре
      2: begin i := i+1 end;
      // Изначально тут опечатка и выполняется просто "i := 2;",
      // что очевидно неверно. Исходная версия:
      {2: begin i := 1+1 end;}

      // В ситуации 3 проход по массиву закончился, но он не последний
      // (т. к. мы меняли элементы в массиве), поэтому начнем новый проход:
      // отметим, что мы пока не меняли массив
      // и поставим индекс на начало массива
      3: begin p := true; i := 1; end;

      // В ситуации 4 закончился последний проход по массиву, поэтому просто
      // отмечаем, что алгоритм завершен.
      4: begin fin := true end;
    end;
  until fin; // выходим из цикла, когда отмечено, что алгоритм завершен

  // выводим на экран сортированный массив
  for i := 1 to n do writeln(A[i]:2:2);

  readln;
end.