Задать направления сортировки методом пузырька в массиве(Pascal)

[_Bac9_]

Как можно задать направления сортировки методом пузырька в массиве?
Например дан двухмерный массив [1..4][1..4], его надо отсортировать по возрастанию как показано на изображений.

[FPaul]

Может быть сделать промежуточный линейный массив с указателями на элемент матрицы - эдакое конформное преобразование - и сортировать массив любым способом.

[alexcoder]

или написать процедуру преобразования линейного индекса в двумерный

[Артём Волжанкин]

Сообщение от alexcoder

или написать процедуру преобразования линейного индекса в двумерный

в целом правильно. Вам не надо направление сортировки. А отсортировать значения и записать в СООТВЕТСТВИИ с вашими линиями

[Артём Волжанкин]

2 цикла:
1 - на подъем по диагонали (увеличение индекса по горизонтали)
2 - на уменьшение индекса по горизонтали
+ условия выбора следующей строки (вниз или в сторону)

[Аватар]

Ну если поймешь и сможешь преподу объяснить

var i,i1,j,j1,k,k1,n,n1,m,m1,t,t1,s: Integer;
    First,First1,Up,Up1: Boolean;
    a: array[1..4,1..4] of Integer;

procedure CalcIndex(pn: Integer; var pm,pt,pi,pj: Integer; var pUp,pFirst: Boolean);
begin
  Inc(pm);
  if pm>pt then begin
    if pUp then pUp:=pt<pn;
    if pUp then Inc(pt) else Dec(pt);
    pm:=1;
    if pFirst=pUp then Inc(pi) else Inc(pj);
    pFirst:=not pFirst;
  end
  else if pFirst then begin Inc(pi); Dec(pj); end
                 else begin Dec(pi); Inc(pj); end;
end;

...
  //массив a заполнен
  //сортировка
  n:=4;
  i:=1; j:=1; m:=1; t:=1; Up:=True; First:=False;
  for k:=1 to n*n-1 do begin
    i1:=i; j1:=j; m1:=m; t1:=t; Up1:=Up; First1:=First;
    for k1:=k to n*n do begin
      if a[i1,j1])<a[i,j]) then begin
        s:=a[i,j];
        a[i,j]:=a[i1,j1];
        a[i1,j1]:=s;
      end;
      CalcIndex(n,m1,t1,i1,j1,Up1,First1);
    end;
    CalcIndex(n,m,t,i,j,Up,First);
  end;

[Артём Волжанкин]

только вывод в порядке возрастания значения к
вместо k подставить отсортированный массив
PS: забыл Pascal совсем

var
n, m:integer;
k:integer;
i,j, p, o, l:integer;
mas: array [1..4] of array [1..4] of integer;
begin
n:=4;
m:=4;
i:=1;
j:=1;
k:=1;
mas[i][j]:= k;
k:=k+1;
while((i<4) or (j<4)) do
   begin
      if (i<n) then i:=i+1 else j:=j+1;

      for i:=i downto 1 do begin
          mas[j][i]:=k;
          k:=k+1;
          j:=j+1;
          if(j>m) then break;
      end;
      j:=j-1;
      if (j<m)then  j:=j+1 else i:=i+1;
      for j:=j downto 1 do
          begin
               mas[j][i]:=k;
               k:=k+1;
               i:=i+1;
               if(i>n) then break;
          end;
      i:=i-1;
   end;

for p:=1 to n do
   begin
      writeln();
      for o:=1 to m do
         begin
            write(mas[p][o]);
            write(' ');
         end;
   end;
end.

[_Bac9_]

Всем спасибо, всем лайки, пойду разбирать код

[FPaul]

И я внесу свои 5 копеек в видение ситуации.
На основе пути в матрице создается массив указателей на элементы матрицы. И этот массив сортируется. Достоинство - произвольный метод сортировки.
В начале и в конце исходника - дань разным вариантам работы с процедурными типами в разных режимах компиляции FPC. Можно везде поставить @, но нельзя привыкать к плохому.

{$mode Delphi}
{.$mode ObjFPC}
{.$mode TP}
{.$mode MacPas}
program SortMatrix;

const
  N  = 4;
  NN = sqr(N);
type
  TMatrix = array[0..N - 1, 0..N - 1] of integer;

type
  PInteger = ^integer;
  TArray = array [0..NN - 1] of PInteger;

type
  TCompFunc = function(const a: TArray; i, j: integer): integer;
  TExchFunc = procedure(var a: TArray; i, j: integer);

  procedure Exchange(var a: TArray; i, j: integer);
  var
    t: integer;
  begin
    t := a[i]^;
    a[i]^ := a[j]^;
    a[j]^ := t;
  end;

  function Compare(const a: TArray; i, j: integer): integer;
  begin
    Compare := a[i]^ - a[j]^;
  end;

  procedure Sort(var a: TArray; comp: TCompFunc; Exch: TExchFunc);
  var
    i, j: integer;
  begin
    for i := 0 to NN - 1 do
      for j := i + 1 to NN - 1 do
        if comp(a, i, j) > 0 then
          Exch(a, i, j);
  end;

  procedure Conform(const M: TMatrix; var a: TArray);
  var
    i, j, k: integer;
  begin
    i := 0;
    j := 0;
    k := 0;
    a[k] := @M[i, j];
    while k < NN do
    begin
      {1. одиночный шаг сверу}
      if j < N - 1 then
        Inc(j)
      else
        Inc(i);
      Inc(k);
      a[k] := @M[i, j];
      if (k = NN - 1) then
        break;
      {2. длинный шаг по диагонали вниз влево}
      while (i < N - 1) and (j >= 0 + 1) do
      begin
        Inc(i);
        Dec(j);
        Inc(k);
        a[k] := @M[i, j];
      end;
      if (k = NN - 1) then
        break;
      {3. одиночный шаг внизу}
      if i < N - 1 then
        Inc(i)
      else
        Inc(j);
      Inc(k);
      a[k] := @M[i, j];
      if (k = NN - 1) then
        break;
      {4. длинный шаг вверх направо}
      while (i >= 0 + 1) and (j < N - 1) do
      begin
        Dec(i);
        Inc(j);
        Inc(k);
        a[k] := @M[i, j];
      end;
    end;
  end;

  procedure ShowMatrix(const M: TMatrix);
  var
    i, j: integer;
  begin
    for i := 0 to N - 1 do
    begin
      for j := 0 to N - 1 do
        Write(M[i, j]: 5);
      writeln;
    end;
  end;

var
  M: TMatrix;
  a: TArray;
  i, j: integer;
begin
  Randomize;
  for i := 0 to N - 1 do
    for j := 0 to N - 1 do
      M[i, j] := Random(900) + 100;
  writeln('There is matrix before sort:');
  ShowMatrix(M);
  writeln('There is matrix after sort:');
  Conform(M, a);
{$if defined(FPC_Delphi) or defined(FPC_MacPas) or defined(FPC_TP)}
  writeln('Delpi || MacPas || TP mode - sort');
  Sort(a, Compare, Exchange);
{$else} {.$ifdef FPC_ObjFPC}
  writeln('ObjFPC mode sort');
  Sort(a, @Compare, @Exchange);
{$endif}
  ShowMatrix(M);
end.