sorted_sequence

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



// crea una struttura SortedSequence e la inizializza
SortedSequence* SortedSequence_init(){
  SortedSequence* s=(SortedSequence*)malloc(sizeof(SortedSequence));
  s->head=NULL;
  return s;
}

// distrugge una struttura sortedSequence e libera la memoria
void SortedSequence_destroy(SortedSequence* s){
  SortedSequenceNode* elem,*succ=s->head;
  free(s);
  while (succ!=NULL){
    elem=succ;
    succ=succ->next;
    free(elem);
  }
}

// stampa una sorted sequence
void SortedSequence_print(SortedSequence* s){
  SortedSequenceNode*succ=s->head;
  while (succ!=NULL){
    printf("%d >> ",succ->value);
    succ=succ->next;
  }
  printf("NULL");
}

SortedSequenceNode* CreaNodo(int e,SortedSequenceNode* next){
    SortedSequenceNode*a=(SortedSequenceNode*)malloc(sizeof(SortedSequenceNode));
    a->value=e;
    a->next=next;
    return a;
}

// inserice un elemento in una sorted sequence
void SortedSequence_insert(SortedSequence* s, SortedSequenceElement e){
  //PRIMO ELEMENTO
  if (s->head==NULL){
    SortedSequenceNode*a=CreaNodo(e,NULL);
    s->head=a;
  }
  //SECONDO ELEMENTO IN POI
  else{
    //CONTROLLA SE È PIU PICCOLO DEL PRIMO
    if(e<s->head->value){
      SortedSequenceNode* a=CreaNodo(e,s->head);
      s->head=a;
    }
    else{
        SortedSequenceNode*ptr=s->head;
        //VA AVANTI FINO A CHE NON TROVA UN ELEMENTO PIÙ GRANDE O NULLO
        while(ptr->next!=NULL&&e>ptr->next->value){
          ptr=ptr->next;
        }
        //SE IL PROSSIMO ELEMENTO ESISTE
        if (ptr->next!=NULL){
          SortedSequenceNode*a=CreaNodo(e,ptr->next);
          ptr->next=a;
        }
        //SE IL PROSSIMO ELEMENTO È NULL
        else{
          SortedSequenceNode*a=CreaNodo(e,NULL);
          ptr->next=a;
        }
    }


  }
}

// inserice un elemento in una sorted sequence solo se non gia' presente nella sequenza
void SortedSequence_insert_unique(SortedSequence* s, SortedSequenceElement e){
//PRIMO ELEMENTO
  if (s->head==NULL){
    SortedSequenceNode*a=CreaNodo(e,NULL);
    s->head=a;
  }
  //SECONDO ELEMENTO IN POI
  else{
    //CONTROLLA SE È PIU PICCOLO DEL PRIMO
    if(e<s->head->value){
      SortedSequenceNode* a=CreaNodo(e,s->head);
      s->head=a;
    }
    else{
        SortedSequenceNode*ptr=s->head;
        //VA AVANTI FINO A CHE NON TROVA UN ELEMENTO PIÙ GRANDE O NULLO
        while(ptr->next!=NULL&&e>ptr->next->value){
          ptr=ptr->next;
        }
        //SE IL PROSSIMO ELEMENTO ESISTE
        if (ptr->next!=NULL){
          if (ptr->next->value!=e){
          SortedSequenceNode*a=CreaNodo(e,ptr->next);
          ptr->next=a;}
        }
        //SE IL PROSSIMO ELEMENTO È NULL
        else{
          SortedSequenceNode*a=CreaNodo(e,NULL);
          ptr->next=a;
        }
    }


  }
}

// rimuove l'elemento in posizione pos
void SortedSequence_removeAt(SortedSequence* s, int pos){
  SortedSequenceNode*ptr;
  if (pos==0){
    ptr=s->head->next;
    free(s->head);
    s->head=ptr;
  }
  else {
    ptr=s->head;
    pos--;
    while(pos!=0){
        pos--;
        ptr=ptr->next;
    }
    SortedSequenceNode*ptr2;
    ptr2=ptr->next->next;
    free(ptr->next);
    ptr->next=ptr2;
  }
}

// trova la posizione dell'elemento e in s, -1 se non esiste
int SortedSequence_find(SortedSequence* s, SortedSequenceElement e){

  if(s->head->value==e)return 0;

  else {
    int index=0;
    SortedSequenceNode*ptr=s->head;
    while(ptr->value!=e&&ptr->next!=NULL){
        index++;
        ptr=ptr->next;
    }
    if (ptr->value!=e)
        return -1;
    return index;
  }
}