SuinFreedom: novembre 2009

giovedì 12 novembre 2009

files: funzioni principali

#include
#include

void scrivif(FILE *);
void leggif(FILE *);
void aggiornaf(FILE *);
void scelta();

main()
{
scelta();
}

void scelta(){
FILE *cf;
int i;
printf("scegliere l'operazione:\n\n1 scrivi\n2 leggi\n3 aggiorna\n\n>");
scanf("%d",&i);
switch(i){

case 1:
scrivif(cf);
break;
case 2:
leggif(cf);
break;
case 3:
aggiornaf(cf);
break;
default:
printf("scelta sbagliata\n");
exit(0);
break;
}

}

void leggif(FILE *cf){
char ch;
if((cf=fopen("file1.txt","r"))==NULL) {printf("il file non esiste\n");exit(1);}
while(!feof(cf)){
fscanf(cf,"%c",&ch);
printf("%c",ch);
}
fclose(cf);
}

void scrivif(FILE *cf){
if((cf=fopen("file1.txt","w"))==NULL) { printf("il file non esiste\n"); exit(1);}
char ch;
scanf("%c",&ch);
while(!feof(stdin)){
fprintf(cf,"%c",ch);
scanf("%c",&ch);
}
fclose(cf);
}

void aggiornaf(FILE *cf){
if((cf=fopen("file1.txt","a"))==NULL) { printf("file file non esiste\n"); exit(1);}
char ch;
scanf("%c", &ch);
while(!feof(stdin)){
fprintf(cf,"%c",ch);
scanf("%c",&ch);
}
fclose(cf);
}

liste funzioni principali, programma2

#include
#include

typedef struct listNode listNode;
typedef struct listNode *List;
typedef int itemType;

struct listNode{
itemType item;
List next;
};

List insertHead(itemType v, List head);
List newNode(itemType v);
List deleteHead(List);
List stampa(List);

main(){
List l=NULL;
int i;
for(i=0;i<10;i++){
l=insertHead(i*10,l);
}
stampa(l);
}

List newNode(itemType v){
List head;
head=(List)malloc(sizeof(List));
head->item=v;
head->next=NULL;
return head;
}

List insertHead(itemType v, List head)
{
List ptr = newNode(v);
ptr->next=head;
return ptr;
}

List deleteHead(List head){
if(head==NULL){printf("la lista e' vuota\n");exit(1);}
List ptr=head;
head=head->next;
free(ptr);
return head;
}

List stampa(List L)
{
if(L==NULL) { printf("NULL\n");exit(0);}
printf("%d->",L->item);
stampa(L->next);
}

Liste ... funzioni principali, programma 1

#include
#include

typedef struct listNode listNode;
typedef listNode *List;
typedef int itemType;

struct listNode{
itemType item;
List next;
};

List newNode(itemType v);
List insertHead(itemType v, List l);
void stampa(List);

main(){
List l=NULL;
int i;
l=insertHead(1,l);
l=insertHead(2,l);
stampa(l);

}

List newNode(itemType v){
List l;
l=malloc(sizeof(List));
l->item=v;
l->next=NULL;
return l;
}

List insertHead(itemType v, List l){
List ptr;
ptr=newNode(v);
ptr->next=l;
return ptr;
}

void stampa(List l){
if(l==NULL){printf("null\n");exit(0);}
printf("%d",l->item);
stampa(l->next);
}

Liste

Liste concatenate

lista1: insert coda
lista2: insert testa
lista3: insert ordinato
lista4: insert ordinato ricorsivo
lista5: insert coda ricorsivo

lista6: contanodi
lista7: elimina elemento testa e coda
lista8: trova max
lista9: trova max ricorsivo
lista10: elimina max
lista11: rovescia iterativo
lista12: rovescia ricorsivo
lista13: ordina e rovescia
lista14: concatena due liste
lista15: ordina e fonde due liste (merge)
lista16: crea e stampa lista circolare
lista17: cerca un valore in una lista circolare
lista18: trova elemento in una lista circolare
lista19: elimina nodo in una lista circolare
coda20: coda

/*
Lista con inserimento iterativo in coda, stampa ricorsiva.
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert(LISTA,int);
void show(LISTA);

main(){
LISTA p=NULL;
int v;

printf("inserire il primo valore ( 0 per terminare ): ");
scanf("%d",&v);
p=insert(p,v);
do{
printf("inserire un valore : ");
scanf("%d",&v);
insert(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}

LISTA insert(LISTA p, int v)
{
if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
LISTA punt=p;
while(punt->next != NULL) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=v;
punt->next=NULL;
return p;
}
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d -> ",p->data);
show(p->next);
}

/*
Lista con inserimento iterativo in testa e stampa ricorsiva.
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert_testa(LISTA,int);
void show(LISTA);

main()
{
LISTA p;
int v;
p=NULL;

do{
printf("inserire un valore: ");
scanf("%d",&v);
p=insert_testa(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}

LISTA insert_testa(LISTA p, int v)
{
LISTA punt=NULL;

if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
punt=malloc(sizeof(LISTA));
punt->data=v;
punt->next=p;
p=punt;
return p;
}
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d -> ",p->data);
show(p->next);
}

/*
lista con inserimento ordinato iterativo e stampa ricorsiva
*/

#include
#include

struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA ins_ord(LISTA,int);
void show(LISTA);

main()
{
LISTA p;
p=NULL;
int v;
do{
printf("inserire un elemento: ");
scanf("%d",&v);
p=ins_ord(p,v);
}while(v!=0);
show(p);
}

LISTA ins_ord(LISTA p, int v)
{
LISTA new, previous, current;

if(p==NULL){ //se la lista e' vuota creo un nodo e ritorno il puntatore al nodo.
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
new=malloc(sizeof(LISTA)); //altrimenti creo un nodo...
new->data=v;
new->next=NULL;
//...e provvedo al posizionamento, ci sono tre casi:

if(new->data < p->data){ //1) new e' il primo nodo
new->next=p;
p=new;
}

previous=p; //2)cerco la posizione corretta
current=p->next;
while(current != NULL && v>current->data){
previous=current;
current=current->next;
}
previous->next=new;
new->next=current;

if(current==NULL){ //3) e' l'ultimo nodo
previous->next=new;
new->next=NULL;
}
return p;
}
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d",p->data);
show(p->next);
}

/*
lista con inserimento ordinato e stampa ricorsivi.
*/

#include
#include

struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA insOrdRic(LISTA, int);
void show(LISTA);

main()
{
LISTA p;
int v;
p=NULL;

do{
printf("inserire un elemento: ");
scanf("%d",&v);
p=insOrdRic(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}

LISTA insOrdRic(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->data>=v){
new=malloc(sizeof(LISTA));
new->data=v;
new->next=p;
return new;
}
else p->next=insOrdRic(p->next,v);
return p;
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d",p->data);
show(p->next);
}

/*
lista con inserimento in coda e stampa ricorsivi
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert(LISTA,int);
void show(LISTA);

main(){
LISTA p;
p=NULL;
int v;
do{
printf("inserire un valore: ");
scanf("%d",&v);
p=insert(p,v);
}while(v!=0);
show(p);
printf("NULL\n");
}

LISTA insert(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->next == NULL){
new=malloc(sizeof(LISTA));
new->data=v;
if(p==NULL)p=new;
else p->next=new;
}
else insert(p->next,v);
return p;
}

void show(LISTA p)
{
if(!p) return;
printf("%d ->",p->data);
show(p->next);
}

/*
Crea una rista di numero di nodi randomizzato, ed elementi a caso,
la funzione contanodi conta i nodi della lista ricorsivamente.
precondizione: nessuna
postcondizione: ritorna il numero di nodi della lista.
*/

#include
#include
#include
#include

struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA crea(LISTA);
void show(LISTA);
int contanodi(LISTA);

main()
{
srand(time(NULL));
LISTA L;
L=NULL;
L=crea(L);
show(L);
printf(" NULL\n");
printf("\n I nodi della lista sono %d\n\n",contanodi(L));
}

int contanodi(LISTA p)
{
if(p==NULL) return;
return 1+contanodi(p->next);
}

LISTA crea(LISTA p)
{
LISTA punt;
int i=1 , n=rand()%10; // printf("\n n: %d\n",n); per verificare il numero scelto di nodi
p=malloc(sizeof(LISTA));
assert(p);
p->data= rand()%10;
p->next=NULL;
punt=p;
while(i
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=rand()%10;
i++;
}
punt->next=NULL;
return p;
}

void show(LISTA p)
{
if(!p) return;
printf(" %d-> ",p->data);
show(p->next);
}

/*
eliminazione iterativa in testa e in coda alla lista
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA l);
void show(LISTA);
LISTA elimina_testa(LISTA);
LISTA elimina_coda(LISTA);

main()
{
LISTA L;
L=NULL;
int v;
L=crea(L);
show(L);
printf("NULL\n");

L=elimina_testa(L);
show(L);
printf("NULL\n");
L=elimina_coda(L);
show(L);
printf("NULL\n");
}

LISTA elimina_coda(LISTA p)
{
LISTA punt,temp;
punt=p;
if(p==NULL || p->next==NULL) return 0;
while(punt->next->next!=NULL) punt=punt->next;
temp=punt->next;
punt->next=NULL;
free(temp);
return p;
}

LISTA elimina_testa(LISTA p)
{
LISTA temp;
if(p==NULL || p->next==NULL) return 0;
else{
temp=p;
p=p->next;
free(temp);
}
return p;
}

LISTA crea(LISTA p)
{
LISTA punt;

p=malloc(sizeof(LISTA));
printf("inserire il primo elemento: ");
scanf("%d",&p->data);

punt=p;
int i=2;
while(i<=5){
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
printf("inserire il %d elemento: ",i);
scanf("%d",&punt->data);
punt->next=NULL;
i++;
}
return p;
}

void show(LISTA p)
{
if(p==NULL) return;
printf(" %d ->", p->data);
show(p->next);
}

//trova il massimo elemento della lista

#include
#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
LISTA elimina(LISTA,int);
void show(LISTA);
LISTA find_max(LISTA);

main()
{

LISTA l=NULL;
int n;
do{
printf("inserire un elemento: ");
scanf("%d",&n);
l=crea(l,n);
show(l);
}while(n!=0);
find_max(l);
}

LISTA find_max(LISTA p)
{
LISTA current,max=p;
if(!p){printf("lista vuota\n");exit(0);}
else{
while(current!=0){
if(current->data > max->data) max=current;
current=current->next;
}
printf("\nil massimo elemento e': %d\n",max->data);
}
return p;
}

LISTA crea(LISTA p,int n)
{
//prec n>0
//post restituisce una lista di elementi allocati in testa di numero n
LISTA punt=p;
if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=n;
p->next=NULL;
}
else{
p=malloc(sizeof(LISTA));
p->data=n;
p->next=punt;
punt=p;
}
return p;
}

void show(LISTA l){
if(!l) return;
printf(" %d -> ",l->data);
show(l->next);
}

/*
La funzione find_max_ric trova il massimo elemento nella lista ricorsivamente.
*/

#include
#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
LISTA elimina(LISTA,int);
void show(LISTA);
LISTA find_max_ric(LISTA,LISTA);

main()
{

LISTA l=NULL;
int n;
do{
printf("inserire un elemento: ");
scanf("%d",&n);
l=crea(l,n);
show(l);
}while(n!=0);
LISTA max=l;
find_max_ric(l,max);
}

LISTA find_max_ric(LISTA p, LISTA max)
{
if(!p) { printf("\n il massimo elemento e': %d\n",max->data);return p;}
if(p->data > max->data) max=p;
find_max_ric(p->next,max);
}

LISTA crea(LISTA p,int n)
{
//prec n>0
//post restituisce una lista di elementi allocati in testa di numero n
LISTA punt=p;
if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=n;
p->next=NULL;
}
else{
p=malloc(sizeof(LISTA));
p->data=n;
p->next=punt;
punt=p;
}
return p;
}

void show(LISTA l){
if(!l) return;
printf(" %d -> ",l->data);
show(l->next);
}

/*
la funzione del_max elimina il massimo elemento della lista
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA);
void show(LISTA);
LISTA del_max(LISTA);

main()
{
LISTA l;
l=NULL;
l=crea(l);
show(l);
printf(" NULL\n");
l=del_max(l);
show(l);
printf(" NULL\n");
}

LISTA del_max(LISTA p){
LISTA previous=p, punt=p, max=p;
if(!p){printf("lista vuota\n");return 0;}
else{
while(punt!=0){
if(punt->data > max->data) max=punt; //trovato il massimo
punt=punt->next;
}

if(max==p){p=p->next; free(max);} //caso del primo nodo
else{
while(previous->next!=max) previous=previous->next;
if(max->next==NULL){previous->next=NULL; free(max);} //caso ultimo nondo
else{
previous->next=previous->next->next;
free(max);
}
}
return p;
}
}

LISTA crea(LISTA p)
{
LISTA punt;

p=malloc(sizeof(LISTA));
p->next=NULL;
printf("inserire un elemento: ");
scanf("%d",&p->data);
p->next=NULL;
punt=p;
int i;
for(i=1;i<5;i++){
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
printf("inserire un elemento: ");
scanf("%d",&punt->data);
}
punt->next=NULL;

return p;
}

void show(LISTA p){
if(!p)return;
printf(" %d -> ",p->data);
show(p->next);
}

/*
la funzione rovescia_iter rovescia una lista di interi iterativamente
*/

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
void show(LISTA);
LISTA rovescia_iter(LISTA);

main()
{
srand(time(NULL));
LISTA l;
l=NULL;
int size=rand()%10;
int v;
int i=0;
do{
v=rand()%10;
l=crea(l,v);
i++;
}while(i
printf("\nsize: %d\n",size);
show(l);
printf(" Null\n");
l=rovescia_iter(l);
show(l);
printf(" Null\n");
}

LISTA rovescia_iter(LISTA p)
{
LISTA current, punt;
current=p;
LISTA result=NULL;
while(current != NULL){
punt=current->next;
current->next=result;
result=current;
current=punt;
}
return result;
}

LISTA crea(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->next==NULL){
new=malloc(sizeof(LISTA));
new->data=v;
if(p==NULL)p=new;
else p->next=new;
}
else crea(p->next,v);
return p;
}

void show(LISTA p)
{
if(!p) return;
printf(" %d -> ",p->data);
show(p->next);
}

//la funzione rovescia_ric rovescia ricorsivamente gli elementi della lista

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA,int);
void show(LISTA);
LISTA rovescia_ric(LISTA);

main()
{
srand(time(NULL));
LISTA l;
l=NULL;
int size=rand()%10;
int v;
int i=0;
do{
v=rand()%10;
l=crea(l,v);
i++;
}while(i
printf("\nsize: %d\n",size);
show(l);
printf(" Null\n");
l=rovescia_ric(l);
show(l);
printf(" Null\n");
}

LISTA rovescia_ric(LISTA p)
{
LISTA temp;
if(p->next==0) temp=p;
else{
temp=rovescia_ric(p->next);
p->next->next=p;
p->next=0;
}
return temp;
}

LISTA crea(LISTA p, int v)
{
LISTA new;
if(p==NULL || p->next==NULL){
new=malloc(sizeof(LISTA));
new->data=v;
if(p==NULL)p=new;
else p->next=new;
}
else crea(p->next,v);
return p;
}

void show(LISTA p)
{
if(!p) return;
printf(" %d -> ",p->data);
show(p->next);
}

/*
crea ordina e inverte una lista concatenata
*/

#include
#include

struct node{
int data;
struct node *link;
};

struct node *insert(struct node *p, int n)
{
struct node *temp;
if(p==NULL){ //caso in cui la lista e' vuota, la inizializzo.
p=(struct node *)malloc(sizeof(struct node));
if(p==NULL){ printf("errore\n");exit(0);}
p->data=n;
p->link=NULL;
}
else{
temp=p;
while(temp->link!=NULL) temp=temp->link; //altrimenti trovo l'ultimo nodo
temp->link=malloc(sizeof(struct node));
if(temp->link==NULL){printf("errore\n");exit(0);}
temp=temp->link;
temp->data=n;
temp->link=NULL;
}
return(p);
}

void print(struct node *p)
{
printf("lista: ");
while(p!=NULL)
{
printf(" %d ->",p->data);
p=p->link;
}
printf(" null\n");
}

struct node *reverse(struct node *p)
{
struct node *prev,*curr;
prev=NULL;
curr=p;
while(curr != NULL){
p=p->link;
curr->link=prev;
prev=curr;
curr=p;
}
return(prev);
}

struct node *sort(struct node *p)
{
struct node *temp1,*temp2,*min,*prev,*q;
q=NULL;
while(p!=NULL){
prev=NULL;
min=temp1=p;
temp2=p->link;
while(temp2 != NULL){
if(min->data > temp2->data)
{
min=temp2;
prev=temp1;
}
temp1=temp2;
temp2=temp2->link;
}
if(prev==NULL) p=min->link;
else prev->link=min->link;
min->link=NULL;
if(q==NULL) q=min;
else{
temp1=q;
while(temp1->link!=NULL) temp1=temp1->link;
temp1->link=min;
}
}
return q;
}

main()
{
int n;
int x;
struct node *start=NULL;
printf("inserire un valore per il numero di nodi: ");
scanf("%d",&n);
while(n-- > 0){
printf("inserire un valore: ");
scanf("%d",&x);
start=insert(start,x);
}
print(start);
start=sort(start);
print(start);
start=reverse(start);
print(start);
}

//concatenare due liste

#include
#include
#include
#include
struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea(LISTA);
void stampa(LISTA);
LISTA concatenate(LISTA,LISTA);

main()
{
srand(time(NULL));
LISTA l;
l=NULL;
l=crea(l);
LISTA m;
m=NULL;
m=crea(m);
printf("lista n 1: ");
stampa(l);
printf("lista n 2: ");
stampa(m);
l=concatenate(l,m);
stampa(l);
}

LISTA concatenate(LISTA a, LISTA b)
{
assert(a!=NULL);
if(a->next==NULL) a->next=b;
else concatenate(a->next,b);
return a;
}

LISTA crea(LISTA p)
{
LISTA punt;
int i;

p=malloc(sizeof(LISTA));
p->data=rand()%10;
p->next=NULL;
punt=p;
for(i=1;i<5;i++){
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=rand()%10;
punt->next=NULL;
}
return p;
}

void stampa(LISTA l)
{
if(!l){printf(" null\n");return;}
printf(" %d->",l->data);
stampa(l->next);
}
//merge sort

#include
#include

struct node{
int data;
struct node *link;
};
struct node *merge(struct node *, struct node *);

struct node *insert(struct node *p, int n)
{
struct node *temp;
if(p==NULL)
{
p= (struct node *) malloc(sizeof(struct node));
if(p==NULL){
printf("errore\n");exit(0);
}
p->data=n;
p->link=NULL;
}
else{
temp=p;
while(temp->link!=NULL) temp=temp->link;

temp->link=malloc(sizeof(struct node));
if(temp->link==NULL){printf("errore\n");exit(0);}
temp=temp->link;
temp->data=n;
temp->link=NULL;
}
return p;
}
void printlist(struct node *p)
{
if(p==NULL){printf("NULL\n");return ;}
printf("%d -> ",p->data);
printlist(p->link);
}

struct node *sortlist(struct node *p)
{
struct node *temp1, *temp2, *min, *prev, *q;
q=NULL;
while(p!=NULL){
prev=NULL;
min=temp1=p;
temp2=p->link;
while(temp2!=NULL){
if(min->data > temp2->data){
min=temp2; prev=temp1;
}
temp1=temp2;
temp2=temp2->link;
}
if(prev==NULL) p=min->link;
else prev->link=min->link;
min->link=NULL;
if(q==NULL) q=min;
else{
temp1=q;
while(temp1->link!=NULL) temp1=temp1->link;
temp1->link=min;
}
}
return q;
}

main()
{
int n;
int x;
struct node *start1=NULL;
struct node *start2=NULL;
struct node *start3=NULL;

printf("inserire il numero di nodi della prima lista: ");
scanf("%d",&n);
while(n-- > 0){
printf("inserire un valore: ");
scanf("%d",&x);
start1=insert(start1,x);
}
printf("la prima lista: ");
printlist(start1);
start1=sortlist(start1);
printf("la prima lista ordinata: ");
printlist(start1);
printf("inserire il numero di nodi della seconda lista: ");
scanf("%d",&n);
while(n-- > 0){
printf("inserire un valore: ");
scanf("%d",&x);
start2=insert(start2,x);
}
printf("la seconda lista: ");
printlist(start2);
start2=sortlist(start2);
printf("la seconda lista ordinata: ");
printlist(start2);
start3=merge(start1, start2);
printf("la fusione delle liste: ");
printlist(start3);
}

struct node *merge(struct node *p,struct node *q)
{
struct node *r=NULL,*temp;
if(p==NULL) r=q; //in caso una delle due sia vuota
else if(q==NULL) r=p;
else{
if(p->data < q->data){
r=p;
temp=p;
p=p->link;
temp->link=NULL;
}
else{
r=q;
temp=q;
q=q->link;
temp->link=NULL;
}
while(p!=NULL && q!=NULL){
if(p->data < q->data){
temp->link=p;
p=p->link;
temp=temp->link;
temp->link=NULL;
}
else{
temp->link=q;
q=q->link;
temp=temp->link;
temp->link=NULL;
}
}
if(p!=NULL) temp->link=p;
if(q!=NULL) temp->link=q;
}
return r;
}

/*creazione e stampa di una lista circolare*/

#include
#include

struct lista{
int data;
struct lista *next;
};

typedef struct lista *LISTA;

LISTA crea_circ(LISTA,int);
void stampa(LISTA);

main(){
LISTA p;
int n;
p=NULL;
do{
printf("inserire un elemento: ");
scanf("%d",&n);
p=crea_circ(p,n);
stampa(p);
}while(n!=0);
}

LISTA crea_circ(LISTA p, int data)
{
LISTA punt,new;
if(!p){
p=malloc(sizeof(LISTA));
p->data=data;
p->next=p;
}
else{
punt=p;
while(punt->next != p) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
}
return p;
}

void stampa(LISTA p)
{
printf("start-> ");
LISTA punt=p->next;
printf(" %d ->",p->data);
while(punt!=p){
printf(" %d ->",punt->data);
punt=punt->next;
}
printf(" start\n");
}

/*
cerca un valore in una lista circolare
*/

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea_circ(LISTA,int);
void stampa(LISTA);
LISTA cerca(LISTA,int);

int main(void)
{
srand(time(NULL));
LISTA p=NULL;
int x;
int cnt=0;
printf("lista creata: \n");
do{
x=rand()%10;
p=crea_circ(p,x);
stampa(p);
cnt++;
}while(cnt<=7);
printf("inerire l'elemento da cercare: ");
scanf("%d",&x);
cerca(p,x);
}
LISTA crea_circ(LISTA p, int data)
{
LISTA punt=p;
if(!p){
p=malloc(sizeof(LISTA));
p->data=data;
p->next=p;
}
else{
while(punt->next!=p) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
}
return p;
}

void stampa(LISTA p)
{
printf("start-> ");
LISTA punt=p;
printf(" %d ->",p->data);
while(punt->next!=p){
printf(" %d->",punt->data);
punt=punt->next;
}
printf(" start\n");
}

LISTA cerca(LISTA p, int x)
{
/*
precondizione: la funzione riceve una lista e un parametro da cercare
postcondizione: restituisce il nodo della lista che contiene l'elemento altrimenti null
*/
LISTA punt;
punt=p;
int cnt=0;
if(p==NULL)return NULL;
do{
if(punt->data==x){printf("l'elemento si trova al nodo numero %d",++cnt);return punt;}
punt=punt->next;
cnt++;
}while(punt!=p);
return NULL;
}
/*
lista circolare: funzione di controllo se un elemento appartiene o no ad una lista
*/

#include
#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA crea_circ(LISTA,int);
void stampa(LISTA);
int find(LISTA,int);

int main(void)
{
srand(time(NULL));
LISTA p=NULL;
int x;
int cnt=0;
printf("lista creata: \n");
do{
x=rand()%10;
p=crea_circ(p,x);
stampa(p);
cnt++;
}while(cnt<=7);
printf("inerire l'elemento da cercare: ");
scanf("%d",&x);
if(find(p,x))printf("l'elemento e' presente\n");
else printf("l'elemento non appartiene alla lista\n");
stampa(p);
}
LISTA crea_circ(LISTA p, int data)
{
LISTA punt=p;
if(!p){
p=malloc(sizeof(LISTA));
p->data=data;
p->next=p;
}
else{
while(punt->next!=p) punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
}
return p;
}

void stampa(LISTA p)
{
printf("start-> ");
LISTA punt=p;
printf(" %d ->",p->data);
while(punt->next!=p){
printf(" %d->",punt->data);
punt=punt->next;
}
printf(" start\n");
}

int find(LISTA p, int x)
{
/*
prec: riceve una lista circolare e un parametro equivalente al valore del nodo da cancellare
post: ritorna la lista dopo aver cancellato il nodo, se il parametro e' presente.
*/
LISTA punt;
punt=p;
if(!p){printf("la lista e' vuota\n");exit(0);}
while(punt->next!=p){
if(punt->data==x){printf(" \n%d trovato\n",punt->data); return 1;}
else punt=punt->next;
}
printf("non trovato\n");
return 0;
}

/*
lista concatenata circolare: funzione di rimozione di un nodo (delete node)
*/

#include
#include

struct lista {
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA add(LISTA ,int);
void stampa(LISTA);
LISTA delete(LISTA,int);

main()
{
LISTA p;
p=NULL;
int n;
do{
printf(">");
scanf("%d",&n);
p=add(p,n);
}while(n!=0);

stampa(p);
printf("inserire l'elemento del nodo da eliminare: ");
scanf("%d",&n);
p=delete(p,n);
stampa(p);
}

LISTA delete(LISTA p, int x)
{
LISTA punt=p,temp;
if(!p){printf("lista vuota\n");exit(0);}
if(p->data==x){
temp=p;
p=p->next;
free(temp);
return p;
}
while(punt->next->data!=x) punt=punt->next;
if(punt->next==p){printf("l'elemento non e' presente\n");exit(0);}
temp=punt->next;
punt->next=temp->next;
free(temp);
return p;
}

LISTA add(LISTA p, int data)
{
LISTA punt;
if(!p){
p=malloc(sizeof(LISTA));
p->next=p;
p->data=data;
return p;
}
punt=p;
while(punt->next!=p)punt=punt->next;
punt->next=malloc(sizeof(LISTA));
punt=punt->next;
punt->data=data;
punt->next=p;
return p;
}

void stampa(LISTA p)
{
LISTA punt;
punt=p;
printf("ptr->");
while(punt->next!=p){
printf(" %d ->",punt->data);
punt=punt->next;
}
printf(" ->ptr\n");
}

/*
Lista con inserimento iterativo in testa e stampa ricorsiva.
*/

#include
#include

struct lista{
int data;
struct lista *next;
};
typedef struct lista *LISTA;

LISTA insert_testa(LISTA,int);
void show(LISTA);

main()
{
LISTA p;
int v;
p=NULL;

do{
printf("inserire un valore: ");
scanf("%d",&v);
p=insert_testa(p,v);
}while(v!=0);
show(p);
printf(" NULL\n");
}

LISTA insert_testa(LISTA p, int v)
{
LISTA punt=NULL;

if(p==NULL){
p=malloc(sizeof(LISTA));
p->data=v;
p->next=NULL;
return p;
}
else{
punt=malloc(sizeof(LISTA));
punt->data=v;
punt->next=p;
p=punt;
return p;
}
}

void show(LISTA p)
{
if(p==NULL) return;
printf("%d -> ",p->data);
show(p->next);
}

/*implementazione di una coda con le due funzioni di inserimento e cancellazione*/

#include
#include

struct coda{
int data;
struct coda *next;
};
typedef struct coda *CODA;

CODA enqueue(CODA,int);
CODA dequeue(CODA);
void show(CODA);

main()
{
int data;
CODA c;
c=NULL;
printf("inserire un valore: ");
scanf("%d",&data);
while(data!=0){
c=enqueue(c,data);
show(c);
printf(" NULL\n");
printf(">\n");
scanf("%d",&data);
}
printf("inserire 1 per eliminare un valore: ");
scanf("%d",&data);
while(data==1){
c=dequeue(c);
show(c);
printf(" NULL\n");
printf("1 per continuare: ");
scanf("%d",&data);
}
show(c);
printf(" NULL\n");
};

CODA enqueue(CODA c, int data)
{
CODA new;
if(c==NULL || c->next==NULL){
new=malloc(sizeof(CODA));
new->data=data;
if(c==NULL) c=new;
else c->next=new;
}
else enqueue(c->next,data);
return c;
}

CODA dequeue(CODA c)
{
CODA punt,temp;
punt=c;
if(c==NULL || c->next==NULL){printf("la coda e' vuota\n"); exit(0);}
while(punt->next->next != NULL) punt=punt->next;
temp=punt->next;
punt->next=NULL;
free(temp);
return c;
}

void show(CODA c)
{
if(!c)return ;
printf(" %d-> ",c->data);
show(c->next);
}

...making ISO

Disk dump:

da cdrom: dd if=/dev/cdrom of=file.iso

da una cartells: mkisofs -o file.iso directory_contenete_i_files

in realta' dd converte e copia i files, infatti per copiare files da cdrom si puo' usare:

dd if=/dev/cdrom of=file.image

if cambia lo stdin e of assegna ad un'altro file lo stdout.

Si puo' usare per scrivere caratteri random su di un file prima di cancellarlo:

ls -l file //individuare la grandezza
dd if=/dev/urandom of=nome_file bs=grandezza_del_file count=1 conv=notrunc

Iscriviti a: Post (Atom)

alcune funzioni relative ai processi

pid_t getpid(void);
pid_t getppid(void);
pid_t fork(void);
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
int execve(const char *filename, char *const argv[], char *const envp[]);

/*
I processi lanciano nuovi programmi con le funzioni della famiglia exec, il processo che chiama una delle funzioni di questa famiglia viene sostituito dal nuovo programma,stack heap e dati vengono ripiazzati;
*/

int execl(const char *path, const char *arg, ...);
int execv(const char *path, char *const argv[]);
int execle(const char *path, const char *arg,...);
int execlp(const char *file, const char *arg,...);
int execvp(const char *file, char *const argv[]);

/*
Controllo di accesso, i processi vengono divisi in gruppi per riuscire ad identificarli, ogni processo ha nome e gruppo;
i gruppi sono 2 in UNIX 4 in Gnu-Linux:
real
effective
saved
filesystem
*/

uid_t getuid(void);
uid_t geteuid(void);
gid_t getgid(void);
gid_t getegid(void);

/*
Gestione degli identificatori dei processi, funzioni utilizzate per cambiare l'identia' di un processo;
*/

int setuid(uid_t uid); // per il group-ID
int setgid(gid_t gid); // per lo user-ID
int setreuid(uid_t ruid, uid_t euid);
int setregid(gid_t, rgid, gid_t egid);
int seteuid(uid_t uid);
int setegid(gid_t gid);
int setresuid(uid_t ruid, uid_t euid, uid_t suid);
int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid);
int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid);
int setfsuid(uid_t fsuid);
int setfsgid(gid_t fsgid);

sorting again... algoritmi di ordinamento in tempo quadratico

#include
#include
#include
#define N 50

void printarr(int *);
void insertionSort(int *);
void selectionSort(int *A);
void bubbleSort(int *A);
void swap(int *a,int *b);
int menu();

main(){
int A[N];
int i;
srand(time(NULL));
for(i=0;i A[i]=rand()%100;
}
printf("Array created:\n");
printarr(A);
int choice=menu();
switch(choice){
case 1:
insertionSort(A);
break;
case 2:
selectionSort(A);
break;
case 3:
bubbleSort(A);
break;
default:
printf("wrong choice\n");
exit(1);
break;
}
printarr(A);
}

int menu(){
printf("\n1) insertion sort\n2) selection sort\n3) bubble sort\n");
int choice;
scanf("%d",&choice);
return choice;
}

void printarr(int *A)
{
int i=0;
while(i++ printf("%d ",A[i]);
printf("\n");
}

void insertionSort(int *A){
int i;
int j,v;
for(i=0;i v=A[i];
for(j=i-1;j>=0;j--){
if(A[j] <= v) break;
A[j+1] = A[j];
}
A[j+1]=v;
}
}

void selectionSort(int *A){
int i,j,min;
for(i=0;i min=i;
for(j=i+1;j if(A[j] min=j;
}
swap(&A[i],&A[min]);
}
}

void swap(int *a,int *b){
int aus=*a;
*a=*b;
*b=aus;
}

void bubbleSort(int *A){
int i,j;
for(i=N-1;i>=0;i--)
for(j=1;j<=i;j++)
if(A[j-1]>A[j])
swap(&A[j-1],&A[j]);
}

Configurazione d-link DWL-G122

lsusb

Bus Device ID e tipo della chiavetta
Il driver : RT2571W/RT2671 sul sito Ralink sezione linux (http://www.ralinktech.com/ralink/Home/Support/Linux.html)
Modifico il file rtmp_def.h aggiungendo l'id della chiavetta nella parte VID/PID se non e' gia' elencata. Questo perche' bisogna inserire nei driver distribuiti da RalinkTech gli id hardware, che sono i seguenti:

a) 0x050d,0x705a per la Belkin F5D7050 V3
b) 0x07d1,0x3c03 per la DLink DWL G122 C1
c) 0x07d1,0x3c04 per la DLink DWL G122 D1
d) 0x2001,0x3c00 per la DLink DWL G122 B1

Installo il pacchetto:

apt-get install build-essential linux-headers $(uname -r) sysutils

Ora compilo i drivers: entro in Module, directory del pacchetto relativo al driver.

cp -v Makefile.6 .-Makefile
make all

Mi da' errore, dice:

make -C /lib/modules/2.6.18_5-686 build no suche file or directory.

Risolvo, o cerco di risolvere, per compilare i moduli in Debian e' meglio usare module-assistant, lo scarico con apt-get, rigiro make-all e funge.

cp -v 2t73.ko /lib/modules/$(uname -r)/kernel/drivers/usb/net

mkdir -pv /etc/Wireless/RT73STA

cp -v rt73.bin /etc/Wireless/RT73STA

dos2unix rt73sta.dat

cp -v rt73sta.dat /etc/Wireless/RT73STA/rt73sta.dat

ora carico il modulo

insmod /lib/modules/$(uname -r)/kernel/drivers/usb/net/rt73.ko

...reinserisco la chiave;
il modulo deve essere caricato ad ogni avvio.

depmod -a

aggiungo rt73 in /etc/modules

Un'altra configurazione ... Netgear WG111v2

Modificare il file /etc/network/interfaces lasciando intatto il segmento di codice riguardante l'interfaccia di loopback e aggiungendo:

allow-hotplug eth1
iface eth1 inet dhcp

Connettersi al router tramite ethernet:

/etc/init.d/networking restart

Installare i tools necessari:

apt-get install ndiswrapper-common ndiswrapper-utils wpasupplicant module-assistant wireless-tools ndiswrapper-source

Per scaricare ed installare il modulo in Debian bisogna usare module-assistant, quindi installarlo:
apt-get install build-essential module-assistant
Lanciarlo:
m-a , o module-assistant

e nel programma seguire i passi:
-PREPARE (installa i componenti)
-SELECT, sceglierer ndiswrapper
-OK
-GET
-BUILD

Il prossimo passo e' quello di installare i driver di windows.
Il driver lo troviamo su ftp://downloads.netgear.com/files/wg111v2_1_3_0.zip , scaricando il pacchetto dobbiamo installare il driver relativo a Win98, quello di XP non funziona.

Scollego la chiavetta e il cavo ethernet.

Installo i driver:

ndiswrapper -i net111v2.inf

controllo l'installazione: ndiswrapper -l

...E configuro; per la configurazione sono 2 i file importanti: /etc/network/interfaces, che deve essere di nuovo modificato a dovere, in questo modo:

auto lo
iface lo inet loopback

auto wlan0
iface wlan inet static
address
netmask 255.255.255.0
network 192.168.0.0
gateway
wireless-essid
wireless-channel 11
wpa-driver wext
wpa-comf /etc/wpa_supplicant.conf

Ora l'ultimo step sta nel configurare la crittografia wpa:
wpa_passphrase nome_rete password, copiare l'output nel file /etc/wpa_supplicant.conf e disabilitare l'interfaccia di rete ethernet con
ifdown eth0
abilitare l'interfaccia di rete wireless con
ifup wlan0
e deamonizzare :

wpa_supplicant -D wext -i wlan0 -c /etc/wpa_supplicant.con -dd -B

Per gestire le dipendenze e creare un modulo:

depmod -a
modprobe ndiswrapper

assicurarsi che nella coda del file /etc/modules compaia ndiswrapper, altrimenti aggiungerlo e finire di configurare l'interfaccia:

iwconfig wlan0 mode managed channel 11 essid nome_rete.

riavviare il computer con la chiavetta inserita...se i passaggi sono stati fatti bene dovrebbe funzionare.

Grub

Volendo installare due sistemi operativi sul mio computer ho dovuto configurare grub, e sono riuscito nell'impresa riscrivendo il file di configurazione /etc/grub.conf.
GNU GRUB e' un boot loader molto potente, poiche' riesce a capire il tipo di filesystem ed il formato dell'immagine del kernel, in modo tale che si puo' caricare un kernel specificandone il nome e la partizione dove risiede, quindi le informazioni riguardo la posizione fisica non sono necessarie, questo lo rende potente e capace di caricare sistemi diversi, per non parlare della flessibilita' di questo programma.
Come prima cosa ho dovuto sgamare i file di configurazione e dove risiedono le immagini dei kernel, poiche' in grub per far caricare un sistema operativo gnu/linux e' necessario elencare le informazioni in questo modo:

title nome_sistema_operativo
root (hd0,1)
kernel /boot/vmlinuz-2.6.23.8-63.fc8 ro root=LABEL=/ rhgb quiet
initrd /boot/initrd-2.6.23.8-63.fc8.img

dopo aver specificato il titolo del sistema operativo si deve specificare il device, tramite il comando
root(hd0,1)
dove hd0 indica il disco rigido, e l'1 la partizione di quel disco rigido dove risiede il sistema operativo.
Il comando root indica a grub il dispositivo a cui deve accedere per bootare il sistema, se il filesystem e' riconosciuto da grub, questo lo monta e prende le informazioni a riguardo.
C'e' il comando rootnotverify che permette di indicare che quel tipo di sistema operativo non e' riconosciuto da grub, il quale non provera' a montare la partizione.In seguito infatti il comando chainloader cerca di bootare qualsiasi sistema trova dalla partizione 0 del primo device (hd0,0).Un esempio possono essere i sistemi operativi che hanno un proprio bootloader installato nella partizione dove essi stessi risiedono.
Le partizioni grub non le chiama allo stesso modo del sistema operativo montato, infatti e' la cosa che mi ha fatto perdere piu' tempo, si puo' risolvere con una distro bootabile oppure con un programma qualsiasi per gestire le partizioni, giusto per avere un idea generale.
Per grub gli hard disk si chiamano hd, i floppy fd, le partizioni le indica iniziando da 0, il nome dei device sono indicati tra parentesi
initrd: il kernel linux e' caricato in memoria durante il processo di boot. Il comando kernel specifica l'immagine bootabile per grub, e il suo argomento e' il nome del file, che si trova in /boot/.

----------------------------------------------------------------------------------------
default=0
timeout=5
splashimage=(hd0,4)/boot/grub/splash.xpm.gz
hiddenmenu

title Fedora (2.6.23.8-63.fc8)
root (hd0,4)
kernel /boot/vmlinuz-2.6.23.8-63.fc8 ro root=LABEL=/ rhgb quiet
initrd /boot/initrd-2.6.23.8-63.fc8.img

title Fedora (2.6.23.1-42.fc8)
root (hd0,4)
kernel /boot/vmlinuz-2.6.23.1-42.fc8 ro root=LABEL=/ rhgb quiet
initrd /boot/initrd-2.6.23.1-42.fc8.img

title Debian
root (hd0,1)
kernel /boot/vmlinuz-2.6.18-5-486 root=/dev/hda2
initrd /boot/initrd.img-2.6.18-5-486
boot
------------------------------------------------------------------------------------------

SuinFreedom