Newsgroup: it.comp.lang.c
Titolo: codice

 
http://www.di.unito.it/~deligu/didattica/algo/EsLabAlg.html
 
Questo è l'indirizzo al quale potete trovare gli esercizi  che il mio
docente di algoritmi ci assegna, con relative soluzioni (a volte).
Io trovo che il testo sia scritto in modo molto artificioso, ma ciò
che non capisco sono le soluzioni!!! le funzioni per la gestione delle
liste (WriteList, ecc) io ho provato a compilarle, gcc me le compila,
ma poi non funzionano...
Per quanto riguarda  le pile non sono riuscito a capire il suo uso
dello stack, per cui ho provato ad implementare una mia versione, che
è appunto il codice incriminato, miostack.c:
________MIOSTACK.C_________
/*       GESTIONE DELLE PILE (STACK). LIFO       */
/*       implementazione tramite le liste                      */
#include <stdio.h>
#include "stack.h"
stack s;
int fact(int x);             /* calcola il fattoriale simulando la  
                                    ricorsione mediante l'uso di uno
                                    stack */
int fact(int x)
{  stack s = EmptyStack;
   int arg, val, control;
   while (top(s) != 1)
   {  s = push(x, s);
      arg = top(s);
      if (arg != 1)
        {  s = push(-1, s);
           val = top(s);
           --x;
        }
      else
       {  s = push(1, s);
          val = top(s);
       }
   }
   control = top(s);
   while (control != x)
   {  s = pop(s);
      s = pop(s);
      s = pop(s);
      control = top(s);
      s = push((val * top(s)), s);
      val = top(s);
   }
   return val;
}
main()
{  int x;
 scanf("%d", &x);
 printf("%d%",fact(x));
}
_________STACK.H___________
/*       GESTIONE DELLE PILE (STACK). LIFO       */
/*       implementazione tramite le liste                       */
/*                 header file                                      */
#include <stdio.h>
#include "liste.h"  /* mi serve per le definizioni dei tipi, per le */
                             /* funzioni Cons, Tail, ecc.... */
typedef ListT stack; /* come ListT per le liste */
const EmptyStack = NULL;
Boolean isEmptyStack(stack s);
stack push(T x, stack s);
stack pop(stack s);
T top(stack s);
/* implementazione */
Boolean isEmptyStack (stack s)
{
  return (isEmptyList(s));
}
stack push(T x, stack s)
{
  return Cons(x, s);
}
stack pop(stack s)
{
  stack t = Tail(s);
  free(s);
  return t;
}
T top(stack s)
{
  return Head(s);
}  
_______LISTE.H________
/*	PROGRAMMA PER LA GESTIONE DI LISTE           */
/*                header file                                 */
#include <stdio.h>
/* definisco il tipo Lnode,costituito da un intero info
e da un puntetore all'Lnode successivo (next) */
typedef enum {false, true} Boolean;
typedef int T;
/* ListT è un puntatore a INode */
typedef struct lnode* ListT;
typedef struct lnode
{
	T info;
        ListT next;
} Lnode;
/*
Prototipi
costruttori dell'ADT Liste
*/
const ListT emptylist = NULL;
ListT Cons (T x, ListT l);
Boolean IsEmptyList (ListT l);
T Head (ListT l);
/* pre: l != EmptyList */
ListT Tail (ListT l);
/* pre: l != EmptyList */
/* implementazione */
ListT Cons (T x, ListT l)
/* funzione per l'inserimento sequenziale di
elementi nella lista */
{
	ListT p;
	p = (ListT) malloc (sizeof(Lnode));
		p->info = x;
		p->next = l;
		return p;
    /* else
		printf("memoria insufficiente");
	  return p; */
}
Boolean isEmptyList (ListT l)
/* restituisce true se la lista è vuota */
{
	return (l == emptylist);
}
T Head (ListT l)
{
	return l->info;
}
ListT Tail (ListT l)
{
	return l->next;
}
Mi piacerebbe sapere cosa ne pensate del mio docente, è molto bravo a
spiegare il C in teoria, ma quando si parla di mettersi a
programmare... sigh :((

 }
qui crea confusione (anche se non sbagliato).
(Non ho avuto voglia di leggere il codice per capire se funzioni)
:)


grazie lo stesso :)