Harjoitus 6.
==============

Tehtävä 1.
==============

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
  char  key;
  struct node *next;
 }alkio;
 
 typedef struct list {
   struct node *nodes;
   }lista;
   
 lista *perusta_lista() {
   lista *l;
   l = (lista *)malloc(sizeof(lista));
   if (l==NULL) return NULL;
   l->nodes= NULL;
   return l;
  }
  
  alkio *luo_alkio() {
    alkio *s;
    s = (alkio *)malloc(sizeof(alkio));
    if (s==NULL) return NULL;
    memset(s,0,sizeof(alkio));
    return s;
    }
    
 int lisaa_alkio(lista *l, alkio *s) {
  s->next = l->nodes;
  l->nodes=s;
  return 1;
  }    
 
 
 void tulosta_lista(lista *l){
  alkio *s;
  for (s= l->nodes; s; s=s->next) 
   printf ("%c", s->key);
  }
  
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */

    lista *kaanna(lista *l){ 
    
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
   alkio *p,*q;
   if(l->nodes) {
     p=(l->nodes)->next;
     /*47*/
     (l->nodes)->next = NULL;
     while (p){
        q=p;
        p=p->next;
        q->next = l->nodes;
        l->nodes=q;
      }
     } 
      return l;
   }
   
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/   
 int main(void) {
 lista *l;
 alkio *s;
 char c;
 /*luodaan  lista peräkkäistä kirjaimista a-g */
  l= perusta_lista();
  if(l==NULL) return 0; /*ei onnistuttu perustamaan listaa*/
  for (c='a'; c<'h'; c++) {
     s = luo_alkio(); 
     if(s==NULL) return -1; /*alkion luominen ei onnistunut */
     s->key = c;
     lisaa_alkio(l,s);
     } 
   tulosta_lista(l);
   printf("\n");
   kaanna(l);
   tulosta_lista(l);
   printf("\n");
   return 1;
   }
      

Tehtävä 2.
========================
#include <stdio.h>
#include <stdlib.h>

typedef struct node {
  int  key;
  struct node *next;
  struct node *prev;
 }dnode;
 
 typedef struct list {
   struct node *first;
   struct node *last;
   int number;
   }dlist;
   
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */   
    dlist *perusta_dlista() {
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
   dlist *l;
   l = (dlist *)malloc(sizeof(dlist));
   if (l==NULL) return NULL;
   l->first= NULL;
   l->last = NULL;
   l->number = 0;
   return l;
  }
  
  dnode *luo_dnode() {
    dnode*s;
    s = (dnode *)malloc(sizeof(dnode));
    if (s==NULL) return NULL;
    memset(s,0,sizeof(dnode));
    return s;
    }
 
 /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/   
 int lisaa_dnode(dlist *l, int i) {
 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 dnode *s, *p, *q;
 
 /*luodaan uusi alkio*/
  s=luo_dnode(); 
  if (s==NULL) return 0;
  s->key = i; 
 
  if (l->number ==0){   /*tyhjä lista*/
      s->next = NULL;
      s->prev = NULL;
      l->first = s;
      l->last  = s;
    }
    else
     if (i<= (l->first)->key)  { /*ensimmäiseksi alkioksi*/
        s->next = l->first;
        s->prev = l->last;
        l->first = s;
        l->last  = s;
       } 
       else { 
       /* etsitään oikea paikka */
        p= l->first;       
        while(p && i > p->key){
          q=p;
          p=p->next;
        }
  
       /* solmu  q:n ja p:n väliin */ 
   
       q->next = s;
       s->prev = q;
       s->next = p;
       if(p) 
         p->prev = s;
         else l->last = s;  /* viimeiseksi alkioksi */
     }  
    l->number++;
    return 1;
  }    
 
 
 void tulosta_dlista(dlist *l){
  dnode *s;
  for (s= l->first; s; s=s->next) 
   printf ("%d,", s->key);
  }
  
  
 int main(void) {
 dlist *l;
 dnode *s;
 int i;
 
 /*luodaan  tyhjä lista  */
  l= perusta_dlista();
  if(l==NULL) return 0; /*ei onnistuttu perustamaan listaa*/
  
  /* listaan numerot 3,.. ,27 */
  for (i=1; i<10; i++) {
       lisaa_dnode(l,3*i);
       }
  tulosta_dlista(l);
  
   /* listan keskelle numero  17*/
   lisaa_dnode(l,17);
   printf("\n");
   tulosta_dlista(l);
   
   /*listan loppuun numero 37*/
   lisaa_dnode(l,37);
   printf("\n");
   tulosta_dlista(l);
   
   /*listan alkuun numero  1*/
   lisaa_dnode(l,1);
   printf("\n");
   tulosta_dlista(l);
   
   printf("\n");
   return 1;
   }
      
   
Tehtävä 3.
===============

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
  int  key;
  struct node *next;
  struct node *prev;
 }dnode;
 
 typedef struct list {
   struct node *first;
   struct node *last;
   int number;
   }dlist;
   
 dlist *perusta_dlista() {
   dlist *l;
   l = (dlist *)malloc(sizeof(dlist));
   if (l==NULL) return NULL;
   l->first= NULL;
   l->last = NULL;
   l->number = 0;
   return l;
  }
  
  dnode *luo_dnode() {
    dnode*s;
    s = (dnode *)malloc(sizeof(dnode));
    if (s==NULL) return NULL;
    memset(s,0,sizeof(dnode));
    return s;
    }
    
 int lisaa_dnode(dlist *l, int i) {
 dnode *s, *p, *q;
 
 /*luodaan uusi alkio*/
  s=luo_dnode(); 
  if (s==NULL) return 0;
  s->key = i; 
 
  if (l->number ==0){   /*tyhjä lista*/
      s->next = NULL;
      s->prev = NULL;
      l->first = s;
      l->last  = s;
    }
    else
     if (i<= (l->first)->key)  { /*ensimmäiseksi alkioksi*/
        s->next = l->first;
        s->prev = l->last;
        l->first = s;
        l->last  = s;
       } 
       else { 
       /* etsitään oikea paikka */
        p= l->first;       
        while(p && i > p->key){
          q=p;
          p=p->next;
        }
  
       /* solmu  q:n ja p:n väliin */ 
   
       q->next = s;
       s->prev = q;
       s->next = p;
       if(p) 
         p->prev = s;
         else l->last = s;  /* viimeiseksi alkioksi */
     }  
    l->number++;
    return 1;
  }    
 
 
 void tulosta_dlista(dlist *l){
  dnode *s;
  for (s= l->first; s; s=s->next) 
   printf ("%d,", s->key);
  }
 
 
 int alkioiden_lkm (dlist *l){
  return (l->number);
  }
  
 int poista_solmu(dlist *l, dnode *s) {
  
 if (l->number){ 
    
  if(l->number == 1) {  /*listan ainoa alkio*/
    l->first = NULL;
    l->last == NULL;
   } 
  else {  /*listassa useita alkioita */
     if (s==l->first)  /*onko ensimmäinen solmu?*/
         l->first = s->next;
      else 
        (s->prev)->next = s->next;  
     if (s==l->last)  /*onko viimeinen solmu?*/
        l->last = s->prev;
      else  
       (s->next)->prev = s->prev;        
     
     
   }
 l->number--;
 free(s);
 return 0;
 }
 else return -1;  /*lista jo tyhjä */
 }
 
 
 dnode *etsi_solmu(dlist *l, int i){
 dnode *p;
 if(l->number == 0) return NULL; /*tyhjä lista*/
 
 /* etsitään  lukua listasta */
 p= l->first;       
 while(p && i >= p->key){
   if (p->key == i) return p;
   p=p->next;
 }
 return NULL;       
}  
  
 int main(void) {
 dlist *l;
 dnode *s;
 int i;
 
 /*luodaan  tyhjä lista  */
  l= perusta_dlista();
  if(l==NULL) return 0; /*ei onnistuttu perustamaan listaa*/
  
  /*alkioiden lukumäärä*/
   printf("Listassa alkioita %d kappaletta.\n", alkioiden_lkm(l));
  
  /*etsitään ja poistetaan tyhjästä listasta */
  if(s= etsi_solmu(l,15)) 
      poista_solmu(l,s);
     else printf("Yritettiin poistaa tyhjästä listasta\n");
   
  lisaa_dnode(l,30); /*listaan yksi alkio*/
  printf("\n");
  /*alkioiden lukumäärä*/
  printf("Listassa alkioita %d kappaletta:", alkioiden_lkm(l));
  tulosta_dlista(l);
  printf("\n");
    
  /*etsitään ja poistetaan listan ainoa alkio */
  if(s= etsi_solmu(l,30)){ 
     printf ("Solmu %d löytyi listasta\n", 30);
     poista_solmu(l,s);
    }  
  printf("Listassa alkioita %d kappaletta:", alkioiden_lkm(l));
  tulosta_dlista(l);
  printf("\n\n");
   
  /* lisätään listaan numerot 3,.. ,27 */
  for (i=1; i<10; i++) 
       lisaa_dnode(l,3*i);   
  
   /* lisätään listan keskelle numero  17*/
   lisaa_dnode(l,17);
  
   /*lisätään listan loppuun numero 37*/
   lisaa_dnode(l,37);
   
   /*lisätään listan alkuun numero  1*/
   lisaa_dnode(l,1);
   
  printf("Listassa alkioita %d kappaletta:", alkioiden_lkm(l));
  tulosta_dlista(l);
  printf("\n\n");
  
   /*etsitään alkioita ja poistetaan löydetyt*/
   if(s= etsi_solmu(l,15)){
      printf ("Poistetaan solmu %d  listasta\n", 15);
      poista_solmu(l,s);
   } 
   tulosta_dlista(l);
   printf("\n\n");
   
   if(s=etsi_solmu(l,16)) /*solmua ei ole listassa*/
      poista_solmu(l,s);
   else 
      printf("Solmua %d ei ole listassa\n", 16);
   tulosta_dlista(l);
   printf("\n\n");
   
  
   if(s= etsi_solmu(l,1))  /*poistetaan ensimmäinen */
      poista_solmu(l,s);
    printf ("Poistetaan solmu %d  listasta\n", 1);  
    tulosta_dlista(l);
     printf("\n\n");
   
   if(s= etsi_solmu(l,37)) /*poistetaan viimeinen*/
      poista_solmu(l,s);
   printf ("Poistetaan solmu %d  listasta\n", 37);
   tulosta_dlista(l);
   printf("\n");
   return 0;
      
   }
      
   
Tehtävä 4.
===========
#include <stdio.h>
#include <stdlib.h>

typedef struct complex {
             double  real;
             double  imag;
             }kluku;
      
kluku *kyhteen(kluku *a, kluku *b){
     kluku *c;
     c = (kluku *)malloc(sizeof(kluku));
     if (c==NULL) return  NULL;
     c->real = a->real + b->real;
     c->imag = a->imag + b->imag;
     return c;
     }
     
kluku *kkerto(kluku *a, kluku *b){
     kluku *c;
     c = (kluku *)malloc(sizeof(kluku));
     if (c==NULL) return  NULL;
     c->real = a->real*b->real - a->imag*b->imag;
     c->imag = a->real*b->imag + a->imag*b->real;
     return c;
     } 
     
     
 int ktulosta(kluku *a){
     if (a->imag  >= 0)
       printf("%e + %ei", a->real, a->imag);
     else
       printf("%e  %ei", a->real, a->imag);
     return 0;
     }
     
 int main(void) {
   kluku *a, *b, *c;
  
   a = (kluku *)malloc(sizeof(kluku));
   if (a==NULL) return  0;
   a->real = -3;
   a->imag = 2; 
   ktulosta(a); 
   printf(" ja ");
   b = (kluku *)malloc(sizeof(kluku));
   if (b==NULL) return  0;
   b->real = 1;
   b->imag = 3;      
   ktulosta(b);
   printf("\n");  
   printf("Ynnätään kompleksiluvuilla:\n(");
   ktulosta(a);
   printf(") + (");
   ktulosta(b); 
   printf(") = ");             
   c=kyhteen(a,b);
   ktulosta(c);
   printf("\n");
   
   printf("Kerrotaan kompleksiluvuilla:\n(");
   ktulosta(a);
   printf(") * (");
   ktulosta(b); 
   printf(") = ");             
   c=kkerto(a,b);
   ktulosta(c);
   printf("\n");
   
   return 0;
   }
 
 

Tehtävä 5. 
===========  
#include <stdio.h>

void main (int argc, char *argv[])
{

FILE *fp;
int c;
int rivilkm=0;

if (argc == 1)
  printf("Yhtään tiedostoa ei annettu.\n");

 else {
   while (--argc > 0) {

     if ((fp=fopen(*++argv,"r"))==NULL) 
       printf("Tiedostoa %s ei löytynyt.\n",*argv);
     else {
       while ((c=getc(fp))!=EOF)
	 if (c=='\n')
	   rivilkm++;

       printf("Tiedostossa  %s on  %d riviä.\n",*argv,rivilkm);
       rivilkm=0;
       fclose(fp);
     }
   }
 } 
}