Pascal/Turbo Pascal - Ordenación ShellSort, ¿visualizarlo paso a paso?

Hola chicos, estoy aprendiendo a "ordenar" con diferentes métodos. Por ejemplo, ahora estoy viendo el método [b]ShellSort[/b], el cual, divide la lista (en la que tengo los valores a ordenar) en grupos de dos....

El caso es que he encontrado un ejemplo de este método por la red y lo que me gustaría saber es: ¿cómo puedo hacer, que tengo que añadir en el código para poder ir viendo paso a paso los cambios que va realizando en la lista?

Por ejemplo, tengo la lista: 1 8 4 3 7. Me gustaría ver paso a paso como va ordenandose. Me ayudáis????? es que no me sale correctamente.

Gracias a todos!!!!

Os paso el código que funciona correctamente:
__________________

program ShellSort;

{modelo de odenacion de "x" enteros aleatorios}
uses
crt;

const
numumElem = 5;

type
rango = 1..numumElem;

Tlista = array [rango] of integer;

var
lista : Tlista;

(*_________________________________*)

procedure lista_aleatoria(var list : Tlista; elementos : integer);
var
i : integer;
begin
randomize;
for i := 1 to elementos do
list[i] := Random(1000);
end;

(*_________________________________*)

procedure visualizar_lista(var list : Tlista; elementos : integer);
var
i : integer;
begin
for i := 1 to elementos do
write(list[i]:6, ' ');
writeln();
end;

(*_________________________________*)

procedure intercambiar(var x, y : integer);
var
aux : integer;
begin
aux := x;
x := y;
y := aux;
end;

(*_________________________________*)

procedure ShellSort(var list : Tlista; num : integer);
var
lista_dividida, i, j, k : integer;
begin
lista_dividida := num div 2;
while (lista_dividida > 0) do
begin
for i := (lista_dividida + 1) to num do
begin
j := i - lista_dividida;
while (j > 0) do
begin
k := j + lista_dividida;
if (list[j] <= list[k]) then
j := 0
else
intercambiar(list[j], list[k]);
j := j - lista_dividida;
end; {while j > 0}
end; {for}
lista_dividida := lista_dividida div 2;
end; {while (lista_dividida > 0)}
end;

(*_________________________________*)

begin
{programa principal}
clrscr;
writeln();
write(' Generar numeros aleatorios: ');
lista_aleatoria(lista, numumElem);
visualizar_lista(lista, numumElem);
writeln();

write(' Ordenacion por ShellSort: ');
ShellSort(lista, numumElem);
visualizar_lista(lista, numumElem);
writeln();
writeln();
end.

Todo método de ordenación incluye un paso inevitable: el intercambio de valores. Creo que lo que deberías hacer es llamar al procedimiento visualizar_lista() al final del procedimiento intercambiar() más un ReadKey (para frenar la ejecución), así podrás ver cómo se mueven los elementos en la lista mientras se ejecuta la ordenación.

En mi página web tengo ese método implementado de forma tal que puedes ver los elementos moverse "gráficamente".

Hola, gracias por tu respuesta!!

Voy a probar lo que me has dicho y tb me pasaré por tu página para descargarme ese código. De nuevo, Gracias!

Hola, pues he probado a insertar el procedimiento visualizar dentro del intercambiar.. pero no entiendo nada de lo que hace porque, por ejemplo, me ha creado la siguiente secuencia de numeros:

Generar numeros aleatorios: 702 672 415 423 848

Y lo que me muestra por pantalla es:

415 672 702 423 848
415 423 702 672 848
415 423 672 702 848

¿Me podéis explicar si está haciendo lo correcto? Es que yo había entendido que el ShellSort divide en grupos de dos, y ordena cada 'grupito'. Una vez ordenado agrupa en grupos de 4 y los ordena, etc. Es así??

Siento las molestias, muchas gracias por vuestra ayuda!

hola Pascalito , ahí va una implementacion antigua casera parecida al metodo SHELL (ojo parecido pero no igual) la he tenido que adaptar al FREE-PASCAL
windows ,para evitar algunas librerias no standar que yo usaba.
el programa está RALENTIZADO busca los delays() y cambia sus valores para
acelerar o ralentizar .
esta en modo texto pero se ve claramente los saltos y valores
A -alto
B- bajo
L-longitud
S-salto
NOTA:si quieres aprender mas observa el code ,está comentado.
SALUDOS y espero que sea de tu agrado.
____________________________________________________

uses crt,ports,video;
var
Modo:TVideoMode;

var
cadena:array[1..50]of string;
cadeno:array[1..50]of char;
cadena_h:array[1..79]of char;
numero:string;
b:integer;
nr:byte;
total:integer;
var
maximo:integer;
matriz:array[1..512] of byte;
a:integer;

{****************************************************************************}
procedure ordenar(var maximo:integer);
var { maximo:longint;}
longitud,salto:integer;
terminado:boolean;
alto,bajo:integer;
a,b,t:integer;
contador:integer;
begin { procedure }
longitud:=maximo;
salto:=1;
while salto <=longitud do begin salto:=salto * 2;end;
while salto >1 do
begin {salto}
{--------------------------------------------------------------------------}
salto:=((salto-1) div 2)+1;

{...........................................}
repeat
terminado:=true;
for alto:=1 to longitud-salto do
begin{for}
bajo:=alto+salto;
{writeln(alto,' ',bajo);}

if matriz[alto]< matriz[bajo] then
begin
sound(39);
delay(150);
nosound;
t:=matriz[alto];
matriz[alto]:=matriz[bajo];
matriz[bajo]:=t;
terminado:=false; {qbasic}
end;

{"""""""""""""""""""""""""""""""""""""""}
{ gotoxy(53,alto);
write(' ');
gotoxy(53,bajo);
write(' ');
}

gotoxy(55,alto);
textcolor(3);

write('<Ä[',matriz[alto]:2,']AÜ');
gotoxy(61,longitud-salto);
textcolor(3);
write('Ü L-S ',longitud-salto);

textcolor(2);
gotoxy(55,bajo);

write('<Ä[',matriz[bajo]:2,']B');

gotoxy(salto,61);

write('salto ',salto);

textcolor(7);
delay(150);
for a:=1 to maximo do
begin

repeat until port[$3da] and 8<>8;


gotoxy(1,a);
textcolor( ((length(cadena[matriz[a]]))mod 15)+1 );
write(cadena_h);clreol;

gotoxy(1,a);
write(cadena[matriz[a]]);{}
write(' [', length(cadena[matriz[a]]),']' );{}clreol;
end;

{"""""""""""""""""""""""""""""""""""""""}

end;{for}

until (terminado);
{............................................}
{---------------------------------------------------------------------------}
end;{salto}

end;{ procedure }
{****************************************************************************}

{--------------------------------------------------------------------------}

begin

textmode(co80+256);
textcolor(7);textbackground(0);
clrscr;

initvideo;
modo.col:=80;
modo.row:=43;
modo.color:=true;
clearscreen;
setvideomode(modo);
setcursortype(0); { sin cursor }



total:=48;
fillchar(cadena_h,total,' ');
randomize;{}
for a:=1 to total do
begin
{inicializamos la matriz poner }
{ tambien podemos poner matriz[a]:=random(a)+1; para valores aleatorios }
matriz[a]:=a;
{write(matriz[a]:4);}
fillchar(cadeno,a,'ß'); { rellenamos }
str(a,numero);
cadena[a]:=cadeno+numero;
cadena[a][0]:=chr(a);
end;

maximo:=total;
ordenar(maximo); { llamamos al procedimiento casero ordenar }
{writeln('-------------------------------------------------------------------');}
writeln;
writeln('proceso terminado pulsa Intro para SALIR');
readln;
end.