Como Invertir Una Lista Enlazada Simple
 

Como Invertir Una Lista Enlazada Simple tomando como parametro solo la lista(L)

me explico:

procedure invertir_lista(var L:nodo);

yo lo hice con 2 listas como veran el codigo abajo. lo cual me corre 100 pts.

pero nesecito que me den una orientacion de como invertirla en la misma lista.
Gracias de antemano.

se los agradesco.

procedure invertir_L(var l:nodo; temp:nodo);
var
e:integer;
begin
__if not esvacio_L(l) then
____begin
______while l <> nil do
________begin
__________e:=primero_L(l);
__________insertarprimero_L(temp,e);
__________eliminarprimero_L(l);
________end;

_________mostrar_L(temp);
_____end;
end;

Hola sant0s y bienvenido a Club Delphi. :)

Como se acostumbra, te invito a que leas nuestra guía de estilo.

Veo que has tenido problemas para identar tu código, pero con el uso de las etiquetas (TAG's) es una taréa sencilla:



Saludos.

muchas gracias lo tomare en cuenta.

Para que lo necesitas?

bueno para tener otra idea como resolver el invertir, sin nesecidad de utilizar 2 lista.
si pudieras darme una orientacion te agradeceria mucho.
gracias por responder

Hola.

Código Delphi [-]
procedure InvertirLista(var Primero: TNodoPtr);
var
  Aux, Prev, Prox: TNodoPtr;
begin
  Aux := Primero;
  Prev:= nil;
  Prox:= nil;
  while Aux <> nil do
  begin
    Prox := Aux.Sgte;
    Aux.Sgte:= prev;
    Prev:= Aux;
    Aux:= Prox;
  end;
  Primero:= Prev;
end;

Saludos.

hola, muchas gracias por responder.
el codigo que me presentaste logre hacerlo funcionar, te digo esto por que hubo muchos otros que encontre pero no me invertian la lista. dicho esto en mi lista tu codigo seria el sigt: dado el echo que en mi lista primero es L.

Código Delphi [-]
procedure InvertirLista(var l:pnodo);
var
  Aux, Prev, Prox: pnodo;
begin
  Aux := l;
  Prev:= nil;
  Prox:= nil;
  while Aux <> nil do
  begin
    Prox := Aux^.sig;
    aux^.sig:= prev;
    Prev:= Aux;
    Aux:= Prox;
  end;
  l:= Prev;
end;

te agradesco mucho por darte el tiempo de responder.
otra cosa, aunque lo hice correr en modo de ejecucion de linea por linea.(F7). no me quedo bien claro la logica del bucle del while. en especial aux^.sig:= prev; prev seria el apuntador ^.sigt de aux

Código Delphi [-]
  while Aux <> nil do
  begin
    Prox := Aux^.sig;
    aux^.sig:= prev;
    Prev:= Aux;
    Aux:= Prox;
  end

;

te agradeceria mucho si me dieras una explicacion.

otro dato.
cuando pongo en comentario la sigt. linea de codigo y ejecuto el programa todo bien.

//Prox:= nil;


pero cuando pongo en comentario la sigt. linea de codigo.

//Prev:= nil;

solo aparece una ventana negra unos instante y desaparece. osea no corre el programa.

y cuando pongo las dos lineas de codigo en comentario

//Prev:= nil;
//Prox:= nil;

lo mismo. solo aparece una ventana negra unos instante y desaparece. osea no corre el programa.

la pregunta seria cual es la importancia de asignarles que sean igual a nil al inicio . si dentro del bucle de while igual le damos una cierta asignacion, puede que sea mi ignorancia pero me queda esa duda.

quisas son una de las muchas preguntas que se hacen todos los que estamos lidiando con este tipo de estructuras. te agradeceria de corazon tu respuesta.

muchas gracias de antemano.

Para aquellos amigos que tampoco puedan entender el codigo anterior aqui les traigo un codigo que invierte la lista.

Código Delphi [-]
procedure InvertirLista(var l: pnodo);
var
  temp,ant: pnodo;
begin
  ant:=l;
  temp:=nil;
    while ant^.sig <>nil do
      begin
        temp:=ant^.sig;
        ant^.sig:=temp^.sig;
        temp^.sig:=l;
        l:=temp
      end;
end;

Si tienen alguna duda simplemente aganla conocer. que congusto respondere. por que la logica si me queda bien clara.
Saludos.

Hola sant0s.

Creo que la mejor forma de entender el funcionamiento del algorítmo es que le realizes una prueba de escritorio.

Saludos.

gracias por tu respuesta, si lo hice la prueba de escritorio. pero aun asi no me quedo muy claro el codigo. por eso puse el el codigo anterior:

Código Delphi [-]
procedure InvertirLista(var l: pnodo);
var
  temp,ant: pnodo;
begin
  ant:=l;
  temp:=nil;
    while ant^.sig <>nil do
      begin
        temp:=ant^.sig;
        ant^.sig:=temp^.sig;
        temp^.sig:=l;
        l:=temp
      end;
end;

pero ahora que me pongo a penzarlo, creo que tu codigo toma en prev como si fuera el nodo que apunta siempre al primero. por eso utiliza 3 variables de tipo nodo en cambio mi codigo solo uza 2 variable de tipo nodos. por eso al final del bucle asigna primero:= prev. de todos modos muchisimas gracias. me ayudo muchisimo a dar con una logica que entendiera a cabalidad sin tu ayuda no lo hubiera logrado. Gracias

Hola santOs.

Es muy probable que el código que pusiste sea más eficiénte que el que te sugerí, pero realmente hacía una montaña de años que no tocaba las listas simplemente enlazadas y al ver que la invertía correctamente, así lo deje... :o

Me alegra que al menos te haya dado un indicio para resolverlo.

Un saludo. :)