алгоритм пузырька на 2 мерном массиве

[-glykaman-]

Я не уверен что до конца въехал в тему, но почему бы не затолкать весь двумерный массив в одномерный, отсортировать, а потом порезать на куски и затолкать обратно в двумерный?

Или я чего то не догнал?

[Mad_Cat]

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

полностью поддерживаю)

[Poma][a]

Я не уверен что до конца въехал в тему, но почему бы не затолкать весь двумерный массив в одномерный, отсортировать, а потом порезать на куски и затолкать обратно в двумерный?

Или я чего то не догнал?

Вариант-то хорошо, НО ТС хочет именно сортировку пузырьком 2-хмерного массива.

Вчера я усердно пытался накатать что-то красивое с указателями, но мои попытки рушил злой Inc. Я надеялся, что инкриментируя указатель, он будет указывать на следующий элемент массива. В строке это прокатывало, НО при увеличении последнего элемента в строке получалось нечто не очень хорошее...

Думал что SetLength сможет помочь, ан нет.. обломался..

type
	TPoint = record
		r, c : Integer
	end;

var
	n, m : Integer;

function Next (t : TPoint) : TPoint;

begin

	Next := t;
	if (t.r = n) and (t.c = m) then begin
		Next.r := 1; Next.c := 1
	end
	else if (t.c = m) then begin
		Next.c := 1; Inc (Next.r)
	end
	else
		Inc (Next.c);

end;



var
	a : array [1..100, 1..100] of Integer;
	i, j, t, count : Integer;
	k, l : TPoint;

begin
	ReadLn (n, m);

	for i := 1 to n do
		for j := 1 to m do
			Read (a[i][j]);

	k.r := 1; k.c := 1;
	l := Next (k);


	for count := 1 to Sqr(n*m) do begin
		if a[k.r, k.c] > a[l.r, l.c] then begin
			t := a[k.r, k.c];
			a[k.r, k.c] := a[l.r, l.c];
			a[l.r, l.c] := t
		end;
		k := l;
		l := Next (k);
                if (k.r = n) and (k.c = m) then begin
                        k.r := 1; k.c := 1;
                        l := Next (k)
                end;


	end;

	for i := 1 to n do begin
		WriteLn;
		for j := 1 to m do
			Write (a[i][j])
	end

end.

[-glykaman-]

Мне кажется тогда нужно будет просто усложнить обычный метод пузырька. Когда-то решал подобное в ВУЗе было интересно.

в теле цикла for используем много условий чтобы изменить сравнения последнего элемента строки с первым элементом следующей строки. при помощи двух переменных i и j. представим что массив 4*4

repeat
a:=true;

for j:=0 to 4 do
for i:=0 to 4 do
begin
if i=4 then //сравнение последнего элемента строки
 begin
 if (i<>4) and (j<>4) then //проводить сравнение только если это не последний элемент массива.
 if (mass[i,j]>mass[0,j+1]) then //если последний элемент строки больше первого элемента след. строки то
   begin
   swap(mass[i,j],mass[0,j+1]); // замена значениями элементов местами
   a:=false;
   end

 end 

else
 begin
if (mass[i,j]>mass[i+1,j]) then //Сравнение соседних элементов 
   begin 
   swap(mass[i,j],mass[i+1,j]);
   a:=false;
   end;
 end;

end;


until a;

Примерно так, код не тестил, могут быть ошибки. Но общая суть думаю понятна?

[BDA]

-glykaman-, ага, и правда, если не брать улучшенные алгоритмы сортировки, то реализовать гораздо проще (т.е. на каждой итерации сортировать весь двухмерный массив).
Мой вариант:

const
  N = 10;
  M = 10;

type
  tarray = array [1 .. N, 1 .. M] of integer;

var
  a: tarray;
  n1, m1, i, j, i1, j1, tmp: integer;
  f: boolean;

begin
  randomize;
  n1 := random(N) + 1;
  m1 := random(M) + 1;
  writeln('Before:');
  for i := 1 to n1 do
  begin
    for j := 1 to m1 do
    begin
      a[i, j] := random(11) - 5;
      write(a[i, j]:3);
    end;
    writeln;
  end;
  repeat
    f := true;
    for i := 1 to n1 do
      for j := 1 to m1 do 
      begin
        j1 := j mod m1 + 1;
        i1 := i + j div m1;
        if i1 > n1 then
          continue;        
        if a[i, j] > a[i1, j1] then
        begin
          tmp := a[i, j];
          a[i, j] := a[i1, j1];
          a[i1, j1] := tmp;
          f := false;
        end;
      end;
  until f;
  writeln('After:');
  for i := 1 to n1 do
  begin
    for j := 1 to m1 do
      write(a[i, j]:3);
    writeln;
  end;
  readln;
end.

[Тамерлан Абилов]

вот теперь другое дело)все в теме))
-glykaman-,да спс большое алгоритм понятен)то же самое про последнюю строку и т.д. как у мну думаю алгоритм внутри итерации я правильно подумал)только разница получается в том что мой более запутан с циклами итераций)а у вас один рипит с булом))спс

BDA, да вот теперь мну легко смотреть и на ваш код и видимо рипит с булом более оптимален.

  j1 := j mod m1 + 1;
        i1 := i + j div m1;
        if i1 > n1 then
          continue;

так понял что продолжает цикл если на последнем элементе строки.а тогда как связано это с ним кроме того что менять на следующий цикл при последнем элементе?

if a[i, j] > a[i1, j1] then

типа.если a[i,j]. то каждый след. элемент в исходной строке с учетом того что элем. строки не последний будет проверять с a[i+1,j]? чего я тут не догоняю?)потому что так алгоритм не работал бы что я не понял)
а так как бы не было и вам спасибо у вас более простой даже не надо проверять последний элемент строки ли)

Poma][a, честно говоря не верю что этот алгоритм будет мне понятен тем более с указателем та(надо читать(

[BDA]

У меня есть элемент с номером [i,j]. Нужно получить следующий за ним элемент.
j1 это номер столбца (номер в строке). i1 это номер строки. Чтобы не делать лишних условных операторов:
j1 = j + 1 преобразую в j1 = (j + 1 - 1) mod m1 + 1 = j mod m1 + 1
Таким образом, если j = m1, то j1 = 1 (переход от последнего элемента в строке к первому). Если этот переход необходим, то нужно также увеличить и номер рассматриваемой строки: i1 = i + j div m1 (если j = m1, то j div m1 = 1, иначе 0). Если i1 стал больше, чем количество строк в массиве, то делается continue (по факту, выход из цикла).

[Тамерлан Абилов]

я смотрел алгоритм про i1 j1 понял но я спрашивал то что понимая что вы сейчас говорите причем тогда

if a[i, j] > a[i1, j1] then

.ведь понимая то что вы сказали как он будет их проверять?)пока j не достигнет m1 то текущий элемент будет проверятся с a[i+1,j] не правильно выражаюсь ли?)вот что я не понял))как он тогда проверяет та))

[BDA]

Не уверен, что понял вопрос.
Пока идем по строке, то сравнивается a[i, j] с a[i, j + 1]. Если дошли до конца строки, то сравниваем с a[i + 1, 1].

UPD
Пожалуйста

[Тамерлан Абилов]

да да совсем то что вы говорите просто mod меня перепутал оказывается))спс большое все понятно