//===================================// Name : lista.cpp
// Author : LORELLA GIANNELLI
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//===================================

//Realizzate con cusori della struttura dati lista

#include <iostream>
#define MAXLUNG 100

using namespace std;
typedef int boolean;
typedef int posizione;
typedef int tipoelem;

typedef struct {
tipoelem info;
posizione succ ;
} compon;

class Lista{

posizione l;
public:

Lista();
~Lista();

Lista(const Lista&);
//Prototipi degli opreratori
void inizialistalibera();
void sposta(posizione&, posizione&);
boolean listavuota();
posizione primolista();
boolean finelista(posizione);
void inslista (tipoelem, posizione);
void canclista(posizione);
tipoelem leggilista(posizione);
posizione succlista(posizione);
posizione predlista(posizione);
void scrivilista(tipoelem,posizione);

};

posizione listalibera=-1;
compon spazio[MAXLUNG];

// prototipi per la gestione del test
void presentazione(void);
void inserisci (Lista &);
void cancella(Lista &);
void scrivi(Lista &);
void assegnazione(Lista &);
void Copia(Lista);
void stampa(Lista &);

//—definizione COSTRUTTORI DISTRUTTORI—-
//Costruttori a 0 arg. implementa lista vuota

Lista::Lista()
{
l=listalibera;
}
//Costruttore di copia

Lista::Lista(const Lista& copia)
{
l=copia.l;
cout<<“n – copia eseguita!!n”;
}

//Distruttore

Lista::~Lista()
{
l=-1;
cout<<“- lista distrutta !n”;
}

//–definizione METODI–
//inizialistalibera(): procedura da richiamare
//all’inizio di ogni programma che utilizza questa
//realizzazione di liste

void Lista::inizialistalibera()
{
posizione i;
listalibera=0;
for(i=0;i<MAXLUNG;i++)
spazio[i].succ=-1;
spazio[MAXLUNG-1].succ=-1;
}

//procedura per uso “interno” a questa realizzazione
//trasferisce la cella puntata da *ph spostandola
//prima della cella puntata da *pk.

void Lista::sposta(posizione &ph,posizione &pk)
{
posizione temp;
temp=pk;
pk=ph;
ph= spazio[pk].succ;
spazio[pk].succ=temp;
}

//listavuota()=b
//Post: b =TRUE=1 se 1 =(vouto); b=FALSE=0 altrimenti

boolean Lista::listavuota()
{
return (l==-1);
}
//primolista()=p
//Post : p =pos(1)

posizione Lista::primolista()
{
return -1;
}

//finelista(p)=b
//Pre : l=<a1 a2 … aN>; p=pos(i) tale che 1<=i<=(N+1)
//Post : b = TRUE =1; se p=pos(i) tale che 1<=i<=(N+1)

boolean Lista::finelista(posizione p)
{
boolean result;

if(p==-1)
result=(spazio[p].succ==-1);
return result;
}

//inslista(a,p)
//Pre: 1=<a1 a2 …aN>; p=pos(i) tale che 1 <=i<=N
//Post: 1 =<a1 a2 …a(i-1)a(i+1) … aN

void Lista::inslista(tipoelem a, posizione p)
{
if (p==-1){
sposta(listalibera,l);
spazio[l].info= a;
}else{
sposta(listalibera,spazio[p].succ);
spazio[spazio[p].succ].info=a;
}
}

//canlista(p)=1
// Pre : l=<a1 a2 … aN>;p=pos(i)tale che 1<=i<=N
//Post: 1=<a1 a2 … a(i-1) a(i+1) … aN>

void Lista::canclista(posizione p)
{
if(p==-1)
sposta(l,listalibera);

else

sposta(spazio[p].succ, listalibera);

}

//leggilista(p)=a
//Pre :=<a1 a2 …aN>; p=pos (i) tale che 1 <=i<= N
//post: a=a(i)

tipoelem Lista::leggilista(posizione p){

tipoelem result;

if(p==-1) result = spazio[l].info;
else
result =spazio[spazio[p].succ].info;
return(result);
}

//scrivilista(a,p)
//Pre : l =<a1 a2 … aN>; p= pos (i) tale che 1<=i <=N+1
//Post : 1 =< a1 a2 … aN a>

void Lista::scrivilista(tipoelem a,posizione p)
{
if (finelista(p))
cout<<“+++errore: lista terminata”;
else if (p==-1)
spazio[l].info=a;
else
spazio[spazio[p].succ].info=a;

}

//succlista(p)=q
//Pre : l=<a1 a2 … aN>: p =pos(i) tale che 1<= i<= N

//post: q =pos (i+1)
posizione Lista::succlista(posizione p)
{
posizione result =(posizione) 0;
if (finelista(p))
cout<<“+++errore; lista terminata. n”;
else
if(p==-1)
result=spazio[p].succ;
return(result);
}

posizione Lista::predlista(posizione p)
{
posizione t;
posizione result=(posizione) 0;
if(p==-1)
cout<<“++errore:fuori dei limiti.n”;
else
if(p==-1)
result=-1;
else{
t=1;
while(spazio[t].succ!=p)
t= spazio[t].succ;
result =t;
}
return (result);
}

int main(void)
{
char risposta=’ ‘, comando;
do{
Lista l;
l.inizialistalibera();

do
{
cout<<“*****LISTA DI INTERI*****”;
if(l.listavuota()) stampa(l);
presentazione();
cout<<“COMANDO SCELTO(I,C,S,F):”;
cout<<“I – inseriren”;
cout<<“C – cancellaren “;
cout<<“S – srivi n”;
cout<<“F – finen”;
cin>>comando;
switch(comando)
{
case ‘I’:inserisci(l); break;
case ‘C’:cancella(l); break;
case ‘S’:scrivi(l);break;
case ‘F’:cout<<“FINE PROGRAMMA”;
}
} while(comando !=’F’);

}while ((risposta==’s’)||(risposta==’s’));

}
void presentazione()
{
cout<<” “;}
void inserisci(Lista &l){
posizione p;
cout<<“FORNIRE LA POSIZIONE DA INSERIRE:”;
int pos;
cin>> pos;
cout<<“FORNIRE L’ELEMENTO DA ISERIRE:”;

tipoelem a;
cin>>a;
int t;
for(t=0;t<pos-1;t++)
p=l.succlista(p);
l.inslista(a,p);
stampa(l);
cout<<“n”;
}

void cancella(Lista &l)
{
posizione p;
p=l.primolista();
cout<<“FORNIRE LA POSIZIONE DELL’ELEMENTO DA CANCELLARE”;
int t,pos;
cin>>pos;
for(t=0;t<pos-1;t++)
p=l.succlista(p);
l.canclista(p);
stampa(l);
cout<<“n”;

}

void scrivi(Lista &l){
posizione p;
p=l.primolista();
cout<<“FORNIRE LA POSIZIONE DELL’ELEMENTO DA SOSTITUIRE”;
int pos;
cin>>pos;
cout<<“FORNIRE L’ELEMENTO:”;
tipoelem a;
cin>>a;
int t;
for(t=0;t<pos-1;t++)
p =l.succlista(p);
l.scrivilista(a,p);
stampa(l);
cout<<“n”;
}

void Copia(Lista ll){
stampa(ll);
}

void assegnazione(Lista &l)
{
Lista ll;
ll=l;
cout<<“VERIFICA DEL COSTRUTTORE DI ASSEGNAZIONE=”;
cout<<“n STAMPA DELLA LISTA”;
stampa(ll);
}

void stampa (Lista& l){
posizione p;
p=l.primolista();
if(l.listavuota())
cout<<“LA LISTA E’ VUOTA”;
else{cout<<“L=<“;
{
while(!l.finelista(p))
{
cout<<l.leggilista(p)<<“”;
p=l.succlista(p);
}
cout<<“>”;
}
}

}