Pascal: Liste

[gokan]

Purtroppo il problema è quello che se nella lista2 ritroviamo anche in ordine sparso gli elementi della lista1 il risultato è sempre TRUE.Ho testato la procedura con un insieme di dati tale da metterla in difficoltà.
Guarda l'output

[cisc]

azzz, scusami, con una piccola modifica dovrebbe funzionare..........

function substringa (l1,l2: puntatore):boolean;
var p1,p2: puntatore;
      b:boolean;

begin
  p1:=l1;
  p2:=l2;
  while (p2<>nil) and (p1<>nil) do
  begin
      p1:=l1;
      b:=true;
         while b do 
          begin
            if (p1^.info<>p2^.info) then b:=false
            else begin
                       p1:=p1^.next;
                       p2:=p2^.next;
                    end;
            if ((p1=nil) or (p2=nil))  then b:=false;         
          end;
  end;
  if ((p1=nil) and (l1<>nil)) then substringa:=true
  	    else substringa:=false;
end;

[gokan]

Non restituisce alcun risultato

[cisc]

come??????
non è possibile che con una modifica del genere non funziona più, sei sicuro????

[bsummer]

Posso suggerire una implementazione per il problema di eliminazione di nodi di posto pari?

funzione toglinodo(p: puntatore, togli:booleano) : puntatore

var p2: puntatore

inizio

  se p==NIL allora p2 = p
  altrimenti
    se togli = true allora 
       inzio
          p2 = toglinodo(p^.next,false)
          libera p
       fine
    altrimenti p^.next = toglinodo (p^.next,true)
  fine 1°altrimenti
  return p2
fine

Versione ricorsiva, mi pare semplice e credo possa funzionare.

Aloha!

[gokan]

Originariamente inviato da cisc
come??????
non è possibile che con una modifica del genere non funziona più, sei sicuro????

Purtroppo si, sono così perso tra alberi, delphi e liste che mi sto rincoglionendo, non so più cosa fare prima!!

[cisc]

x bsummer:

a me viene in mente sempre questa procedura ricorsiva per quel problema, ma bisogna passargli p^.next e nn p come parametro.

procedure eliminapari (var p: puntatore;);
var pa: puntatore;

begin
   if (p<>nil) begin
                       pa:=p;
                       p:=p^.next;
                       dispose (pa);
                       eliminapari (p^.next^.next);
                   end;
end;

la tua procedura mi sembra a prima vista ottimizzabile........


x gokan:
la proceura substringa che ho scritto eve per forza restituire o vero o falso, controlla di averla trascritta correttamente

[bsummer]

Originariamente inviato da cisc
x bsummer:

procedure eliminapari (var p: puntatore;);
var pa: puntatore;

begin
   if (p<>nil) begin
                       pa:=p;
                       p:=p^.next;
                       dispose (pa);
                       eliminapari (p^.next^.next);
                   end;
end;

la tua procedura mi sembra a prima vista ottimizzabile........

La procedura che hai scritto è compatta, chiara e va benissimo...se non per un piccolo caso

Infatti se p è diverso da nil, ma p^.next è nil, cosa succede se passi alla funzione p^.next^.next ?
Bisognerebbe fare un piccolo controllo.

Per quanto riguarda la mia procedura, si, penso sia ottimizzabile.

Aloha!

[gokan]

Originariamente inviato da cisc
x gokan:
la proceura substringa che ho scritto eve per forza restituire o vero o falso, controlla di averla trascritta correttamente

Ho fatto copia ed incolla, restituisce un risultato solo se la lista1 e 2 non superano 2,3 elementi.
Ciao

[gokan]

Mi dareste una mano a migliorare questa funzione (possibilmente deve essere ricorsiva). Essa confronta due liste e restituisce TRUE se sono uguali, FALSE altrimenti.

Function Uguali(lis,lis2:puntatore):boolean;
begin
if (lis<>NIL) AND (lis2<>NIL) then
 if lis^.info<>lis2^.info then Uguali:=FALSE
    else
      Uguali:=Uguali(lis^.next,lis2^.next);
end;

Il problema è che se le due liste sono di lunghezza diverse ma molto simili, la funz mi da sempre TRUE. Ad esempio
lis->c->a->r->NIL
lis2->c->a->r->n->e->NIL
Fanno restituire True, dovrei mettere un controllo dove c'è 'else', prima di fare eseguire Uguali:=Uguali(lis^.next,lis2^.next);

[bsummer]

Prova questo:

Function Uguali(lis,lis2untatore):boolean;

var a, b :boolean;
begin

  if lis<>nil then a:= true
    else a:=false;
  if lis2<>nil then b:= true
    else b:=false;

  a = (a and b);

  if a = true then
  begin
    if lis.info <> lis2.info then uguali:=false
      else Uguali:=Uguali(lis^.next,lis2^.next);
  end else uguali:=false;
end;

Aloha!

[cisc]

prima cosa, così funziona:

function substringa (l1,l2: puntatore):boolean;
var p1,p2: puntatore;
      b:boolean;

begin
  p1:=l1;
  p2:=l2;
  while (p2<>nil) and (p1<>nil) do
  begin
      p1:=l1;
      b:=true;
         while b do 
          begin
            if (p1^.info<>p2^.info) then begin
                                                              b:=false;
                                                              p1:=p1^.next;
                                                              p2:=p2^.next;
                                                          end
            else begin
                       p1:=p1^.next;
                       p2:=p2^.next;
                    end;
            if ((p1=nil) or (p2=nil))  then b:=false;         
          end;
  end;
  if ((p1=nil) and (l1<>nil)) then substringa:=true
  	    else substringa:=false;
end;

per la funzione uguali sono d'accordo con bsummer.

per eliminapari, hai ragione , diventerebbe così:

procedure eliminapari (var p: puntatore;
var pa: puntatore;

begin
   if p<>nil begin
                       pa:=p;
                       p:=p^.next;
                       dispose (pa);
                       if p^.next<>nil then eliminapari (p^.next^.next);
                   end;
end;

[gokan]

La procedure subStringa non funziona ancora perfettamente (vedi output),la funzione UgualiListe non funziona bene, restituisce sempre false!!
Doma vi faccio sapere se riesco a migliorare qualcosa!!
Ciao e grazie ancora a tutti e due!!

Ah, la procedura eliminapari (dovrebbe eliminare gli elementi di posto pari di una lista) non funziona, elimina tutti gli elementi tranne l'ultimo.
Perchè passare la testa della lista per riferimento? La testa non verrà mai eliminata (essendo di posto uno, cioè dispari)?

[bsummer]

Originariamente inviato da gokan
la funzione UgualiListe non funziona bene, restituisce sempre false!!

Perchè sono un coglione! E' ovvio che gli ultimi 2 nodi sono NIL e quindi se entrambi sono NIL la funzione deve restituire true!
Invece com'è fatta ora questo caso non lo prende in considerazione...ci vuole una modica...

[cisc]

function substringa (l1,l2: puntatore):boolean;
var p1,p2: puntatore;
      b:boolean;

begin
  p1:=l1;
  p2:=l2;
  while (p2<>nil) and (p1<>nil) do
  begin
      p1:=l1;
      b:=true;
         while b do
          begin
            if p1^.info<>p2^.info then   b:=false
            else p1:=p1^.next;
            p2:=p2^.next;
            if ((p1=nil) or (p2=nil))  then b:=false;
          end;
  end;
  if ((p1=nil) and (l1<>nil)) then substringa:=true
  	    else substringa:=false;
end;

[gokan]

Originariamente inviato da cisc

function substringa (l1,l2: puntatore):boolean;
var p1,p2: puntatore;
      b:boolean;

begin
  p1:=l1;
  p2:=l2;
  while (p2<>nil) and (p1<>nil) do
  begin
      p1:=l1;
      b:=true;
         while b do
          begin
            if p1^.info<>p2^.info then   b:=false
            else p1:=p1^.next;
            p2:=p2^.next;
            if ((p1=nil) or (p2=nil))  then b:=false;
          end;
  end;
  if ((p1=nil) and (l1<>nil)) then substringa:=true
  	    else substringa:=false;
end;

Adesso funziona alla grande

[gokan]

Ecco come deve essere la funzione di Uguaglianza Liste

Function Uguali(lis,lis2:puntatore):boolean;
begin
if (lis<>NIL) AND (lis2<>NIL) then
   begin
 if lis^.info<>lis2^.info then Uguali:=FALSE
    else //if lis^.info=lis2^.info then
       Uguali:=Uguali(lis^.next,lis2^.next)
   end
else if ((lis=NIL)AND(lis2<>NIL))OR((lis<>NIL)AND(lis2=NIL)) then
 Uguali:=False;
end;

[gokan]

Salve a tutti ho un problemino apparentemente stupido. Dovrei costruire una lista che mi consenta di scegliere quale elelento iinserire e dopo quale inserirlo.
Esempio
lis->6->2->9->NIL

Voglio inserire l'elemento 5 dopo l'elemento 2. Dovrebbe essere così lis->6->2->5->9->NIL.
Ho costruito tale procedura, che ha il difetto di eliminare tutti i valori che seguono quello inserito, ad esempio l'output sarebbe stato:lis->6->2->5->NIL (ho perso il 9).
Dateci un'occhiata e datemi qualche consiglio:

Procedure InsDopo(var lis1:puntatore; dopoValore,qualeValore: integer);
var
 pNuovo:puntatore;
begin
if lis1<>NIL then
 begin
 if lis1^.info=dopoValore then
  begin
  new(pNuovo);
  lis1^.next:=pNuovo;
  pNuovo^.info:=qualeValore;
  pNuovo^.next:=lis1^.next^.next;
  end
 else
   InsDopo(lis1^.next,dopoValore,qualeValore);
 end;
end;

[bsummer]

PRIMA

pnuovo^.next := list1^.next;

e DOPO

list1^.next:=pnuovo;


Altrimenti si che perdi la coda...

[gokan]

Originariamente inviato da bsummer
PRIMA

pnuovo^.next := list1^.next;

e DOPO

list1^.next:=pnuovo;


Altrimenti si che perdi la coda...

azz.. mi sono rimbambito, hai ragione, come facevo a non accorgemene