Errore di segmentazione della memoria.

[3nigma666]

io ho questo codice ke sto implementando per l universita.Il codice è commentanto credo abb bene (ci puo essere qlk commento qua e la sballato in quanto devo sistemare il codice.Cmq il problema è ke in questo codice (se compilato perfettamente funzionante) prende in input un vettore disordinato di 10 - 20 - 50 - 100 - 200 - 500 - 1000 - 5000 elementi e ne calcola il tempo di esecuzione dell algoritmo,il tempo medio di esecuzione su 1 campione di 500 vettori (in quanto per ogni vettore di n input (10 - 20 ecc) genera 500 vettori disordinati differenti per poi ordinarli)
Gli algoritmi di esecuzione presi in considerazione sono QuickSort,InsertionSort e HeapSort.Per quanto riguarda QuickSort e Insertion sort nessun problema,il vero problema è heapsort,nel senso ke mi da errore di segmentazione della memoria come se uscisse un indice fuori dal vettore..ma mi appare molto strana la cosa...
Cmq vi allego prima tutto il codice senza la parte ke d errore e poi a parte allego il sorgente ke da errore,implementato come se fosse 1 programma a parte cosi se volete compilarlo per vedere come mai fa errore.

-------------------------CODICE COMPLETO--------------------

//----------------------------------------------------------------------------------
// Università agli studi di Udine 
// Anno Accademico : 2004/2005
// Studente : Valerio Bignardi
// Name  : QuickSort HeapSort Insertion Sort
// Desc  : Funzione ke prende in input un vettore di lunghezza definita da MAX,
//         dove ogni elemento del vettore è generato casualmente dalla funzione Random
//       - QuickSort di divide essenzialmente in 2 funzioni:
//         -Partition ke assegna un pivot e scandisce il vettore
//         -Swap ke inverte due elementi da ordinare
//         -QuickSort ke richiama ricorsivamente se stesso passando a se stesso prima l'albero sx 
//          e poi l'albero dx  
//          HeapSort crea una struttura dati ordinata
//          Insertion sort inserisce nella posizione adeguata l elemeno in condiderazione
//          Lo scopo del programma non è quello di ordinare un vettore tramite il metodo del Quicksort
//          HeapSort o InsertionSort,ma bensi analizzare quanto tempo impiega ogni singolo algoritmo,
//          nel caso medio ad ordinare il vettore al variare della sua lunghezza:
//          (10 - 20 - 50 - 100 -200 - 500 - 1000 - 5000 elementi)
//          Per fare cio bisogna prima di tutto individuare quante ripetizioni sono necessaria affinche'
//          l'ordinamento del vettore avvenga in un tempo superiore al tempo minimo misurabile dalla
//          macchina.Dopo aver trovato il numero di ripetizioni a seconda dell'input viene,
//          calcolato il tempo necessario per effettuare n (dove n è il numero di ripetizioni) ordinamenti
//          del vettore casuale generato dalla Funzione Random.Da questo tempo viene sottratto il tempo 
//          definito come Tara ovverosia il tempo necessario a creare il vettore ,copiarlo in un vettore
//          di backup (in questa maniera passo alla funzione QuickSort un vettore sempre disordinato ad ogni 
//          iterazione)
//          Le n ripetizioni di ordinamento vengono ripetutte da 0 per 500 volte affinche il campione di
//          vettori da ordinare non sia solo 1.
//  Vers  : 0.99
//  ToDo  : Implementare il calcolo del tempo di esecuione tramite la funzione clock() e 
//          immettere un numero di ripetizione tali ke l'esecuzione del programma sia maggiore
//          dell'orologio di sistema
//  Bugs  : N.P.
//----------------------------------------------------------------------------------
#include <iostream>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>





//DICHIARAZIONE DELLE COSTANTI


#define LINUX 
#define A 16087
#define M 2147483647
#define Q 127773
#define R 2836




//DICHIARAZIONE DELLE VARIABILI E INIZIALIZZAZIONE



// Dichiaro la costante intera max inizializzata a 10000
int j = 0;
int q = 0;
int pivot = 0;
int i = 0;
float t0 = 0; //Istante di tempo t0
float t1 = 0;
float t2 = 0;
float t3 = 0;
int ripetizioni = 0;
int QS = 0;//esegui quicksort
int HS = 1;//esegue HeapSort
int IS = 2;//Esegue InsertionSort
int modalita = 0;
float T_parziale_QS = 0;
float T_parziale_IS = 0;
float T_parziale_HS = 0;
float tempo_tot_QS = 0;
float tempo_tot_IS = 0;
float tempo_tot_campione_QS = 0;
float tempo_tot_campione_IS = 0;
float media_QS = 0;
float media_IS = 0;
char* buffer;
char* buffer2;



//long vettore [max];// Dichiaro un array di nome vettore, di dimensione max.

double seed;  //Variabile globale ke contiene il seme della funzione random





//-------------------------------------------------------------
// Name   :   Random()
// Desc   :   funzione Random() che restituisce un numero casuale compreso tra 0 e 1
// ToDo   :   Nulla ;)
//----------------------------------------------------------------------



double Random()
{
   double lo, hi, test;
   hi = ceil(seed / Q);
   lo = seed - Q * hi;
   test = A * lo - R * hi;
   if (test < 0.0) {
      seed = test + M;
   } else {
      seed = test;
   } /* endif */
   return seed / M;
} //end random




/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
////                     ALGORITMI DI ODINAMENTO                                 ////   
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////


//--------------------------------------------------------------------------------
// Name  :  swap(long& a, long& b)
// Desc  :  Questa funzione implementa lo scambio dei valori con 
//          la tecnica inplace, ovverosia senza alcuna variabile di supporto
//          Si noti che i parametri sono passati per riferimento, altrimenti 
//          le modifiche sarebbero effettuate su copie di essi, e lo scambio di valore non ci sarebbe.
// ToDo  :  Nulla  :D
// Vers  :  1.0
//----------------------------------------------------------------------------------------



void swap (long& a, long& b) {
	a = b + a; //      (a+b)          b
	b = a - b; //      (a+b)        (a+b)-b
	a = a - b; //      (a+b)-a        a
};



//-----------------------------------------------------------------------
// Name  :  Partition 
// Desc  :  Prende come parametri puntatore ad un vettore, indice sinistro ,indice destro
//          Inizia a scorrerre il vettore partendo da fuori il vettore
//          e inizia un loop ke continua fino a quando l'indice sx è minore dell'indice dx
//          Dentro al loop viene fatto scorrere il vettore e ogni singolo elemento del vettore
//          viene confrontato con il pivot e se maggiore viene messo a dx se inferiore viene
//          posizionato a sx tramite la funzione swap
// ToDo :   Nulla
// Vers :   1.0
// Bugs :   N.P.
//-----------------------------------------------------------------------------------------



int Partition (long* vett,int left,int right){
     pivot = vett[left];//a pivot assegno il primo elemento
     i = left - 1 ;    //inizio da fuori il vettore
     j = right + 1;   //inizio da fuori il vettore
    //fino a quando l indice inferiore non supera l indice superiore continua a cercare gli elementi 
    while (i < j){
		do{j--;} //decrementa di una posizione l'indice superiore
		while (vett[j]>pivot); //continua a decrementare fino a quando l elemento trovato nn è maggiore del pivot
		do{ i++;}
		while (vett[i]<pivot);//continua a decrementare fino a quando l elemento trovato nn è minore del pivot
		if (i<j)
			swap(vett[i],vett[j]);//inverti i due valori
        else                  
           return j;// se i ha superato j ritorno il nuovo pivot a Qsort
     }//end while
}//end partition                                 

         

//-------------------------------------------------------------
// Name  :  QuickSort
// Desc  :  Assegna un valore a al pivot q.la funzione richiama se stessa
//          ricorsivamente passandosi prima l'albero di dx e poi quello di sx
// ToDO  :  Nulla :D
// Vers  :  1.0
// Bugs  :  N.P
//-----------------------------------------------------------

void QuickSort (long* vett,int left,int right){
     if (left < right){
              q = Partition (vett,left,right); //Assegnazione pivot
              QuickSort(vett,left,q);//albero di sinistra
              QuickSort(vett,q+1,right);//albero di destra
              }//end if

}//end quicksort


//------------------------------------
// Name : InsertionSort
// Desc : Funzione ke ordina un vettore inserendo l'elemento interessato nella giusta posizione
// ToDo : Nulla ;)
// Vers : 1.0
// -------------------------------------

void InsertionSort(long* vett,int max){
     int key = 0;
     int i = 0;
     for (int j=1;j<max;j++)
     {
         key = vett[j];
         i = j -1;
         while (i >= 0 && key < vett[i]){
               vett[i + 1] = vett[i];
               i = i-1;
         }//end while
         vett[i+1]=key;
     }//end for
    
}//end InsertionSort








/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
////                     Funzioni Relative Alla GUI                              ////   
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

//---------------------------------------------------------------------
// Name : Menu
// Desc : GUI ke permette di selezionare 
//        il numero di elementi nel vettore con il suo tempo minimo appropriato d
//        esecuzione tale ke il l'intervallo minimo di confidenza sia il 95 %
// ToDO : Nulla ;)
//--------------------------------------------------------------------------

int menu(){
     int scelta = 0;
     int err = 0;
     do{     
        err = 0;
        std::cout<<"1.Esegui algoritmo di QuickSort"<<std::endl;
        std::cout<<"2.Esegui algoritmo di HeapSort"<<std::endl;
        std::cout<<"3.Esegui algoritmo di InsertionSort"<<std::endl;
        std::cout<<"4.Esegui in successione QuickSort, HeapSort e InsertionSort"<<std::endl;
        std::cout<<"0.Fine"<<std::endl;
        std::cin>>modalita;
        if (modalita == 1)
           buffer = "QS.txt";
        
        if (modalita == 2)
           buffer = "HS.txt";
                     
        if (modalita == 3)
           buffer = "IS.txt";
        
        if (modalita == 0)
        {//free(buffer);
         exit(0);}
        
        if (modalita == 1 || modalita == 2 || modalita == 3){
        #if defined __linux__
        system("clear");
        #elif defined WIN32
        system("cls");
        #endif
        std::cout<<std::endl;
        std::cout<<"Seleziona il numero di elementi del vettore: "<<std::endl;
        std::cout<<std::endl;
        std::cout<<"1:   10 elementi"<<std::endl;
        std::cout<<"2:   20 elementi"<<std::endl;
        std::cout<<"3:   50 elementi"<<std::endl;
        std::cout<<"4:  100 elementi"<<std::endl;
        std::cout<<"5:  200 elementi"<<std::endl;
        std::cout<<"6:  500 elementi"<<std::endl;
        std::cout<<"7: 1000 elementi"<<std::endl;
        std::cout<<"8: 5000 elementi"<<std::endl;
        std::cout<<"9: Esegui in successione 10,20,50,100,200,500,1000,5000 elementi"<<std::endl;
        std::cout<<"0: FINE"<<std::endl;
      
     std::cin>>scelta;}
     else{
          if (modalita != 4){
          #if defined __linux__
          system("clear");
          #elif defined WIN32
          system("cls");
          #endif
          std::cout<<std::endl;
          std::cout<<"Hai sbagliato selezione,scegli nuovamente"<<std::endl;
          std::cout<<std::endl;
          err = 1;
          }
          if (modalita == 4){   
           buffer = "QS_IS_HS.txt";
           std::cout<<"verrano ora ordinati i vettori di elementi:"<<std::endl;
           std::cout<<"10 - 20 - 50 - 100 - 200 - 500 - 1000 - 5000"<<std::endl;
           std::cout<<"Con tutti e tre gli algoritmi di Ordinamento";
           scelta = 9;
           }       
         }
     }while (err==1);     
     return scelta;
     }//end menu

/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
////                     FUNZIONI RELATIVE AL CALCOLO DEL TEMPO                  ////
/////////////////////////////////////////////////////////////////////////////////////   
/////////////////////////////////////////////////////////////////////////////////////


   //-------------------------------------------------------------
   //  Name : Tminimo 
   //  Desc : Funzione ke prende in input l'errore massimo tollerato nel nostro caso 5 %
   //         e assegan a t0 e t1 l'isntante iniziale e finale del conteggio,e ripete un ciclo ove
   //         all'interno viene assegnato all'istante finale il clock,fino a quando 
   //         la loro differenza è > 0
   //  ToDo : Verificare effettivo Funzionamento della Funzione
   //  Bugs : N.P.
   //--------------------------------------------------------------------
         float Tminimo(int err)
               {
                float t0 = clock();
                float t1 = clock();
                while ((t1 - t0) == 0)
                t1 = clock();
                float delta = (t1 - t0)/CLOCKS_PER_SEC;
                float Tmin = (delta * 100)/err;
                return Tmin;
               }

  //--------------------------------------------------------
  // Name  :  Copiavettore 
  // Desc  :  Copia in temp il vettore vett
  // ToDo  :  Nulla ;)
  // Vers  :  1.0
  //-------------------------------------------------------
  long* copiavettore (long* vett,long* temp,int max){
             for (int k=0;k<max;k++) //copia il vettore
              temp[k] = vett[k];
             return temp; // ritorna il vettore
             }    
 //--------------------------------------------------------
  // Name  :  Ripetizioni 
  // Desc  :  Calcola sulla funzione copiavettore il numero di ripetizioni in base al 
  //          minimo tempo misurabile
  // ToDo  :  Nulla ;)
  // Vers  :  1.0
  //-------------------------------------------------------             
      int Ripetizioni (long* vett,long* temp,int max,float Tmin){
          float t0 = clock();
          float t1 = clock();
          int rip = 0;
          while (((t1 - t0)/CLOCKS_PER_SEC) < Tmin  ){//MENTRE t1 - t0 è <di Tmin esegui
             /* for (int k=0;k<max;k++) //Copia il vettore
              temp[k] = vett[k];*/
               copiavettore(vett,temp,max);
              //QuickSort (vett,0,(max-1));
              t1 = clock();//assegna nuovo tempo a t1
              rip ++;//incrementa il numero di ripetizioni
              }
              return rip/2;//dimezzo il numero di ripetizioni in quanto copiavettore è lineare mentre Quicksort è nlogn di conseguenza sono sufficienti meno ripetizioni
          }    

//------------------------------------------------------------------------------------
// Name : Tara 
// Desc : Funzione ke necessita al calcolo finale della complessita di QuickSort
//        Questa funzione calcola quanto tempo impiega la cpu ad eseguire la creazione
//        di elementi random per il vettore dopo n ripetizioni.
//        Sarebbe stato decisamente piu efficace implementare il calcolo del tempo
//        nel main quando chiamo effettivamente la funzione Random e non fittiziamente come fatto ora.
//        Ma purtroppo cio' non è possibile in quanto in ongi singolo ciclo il tempo con il quale 
//        viene eseguito random è troppo piccolo per l'orologio di sistema,percio devo effettuare
//        a parte 398900 ripetizioni della funzione e calcolarne il tempo impiegato
// Vers : 1.0
// ToDo : Nulla ;D
//---------------------------------------------------------------------------------------

float Tara (long* vettore,long* temp,int max,int rip){
      int t = 0; //Inizializzo a 0 il contatore
      float t_iniz = clock();    //Assegno il valore a Tempo_iniziale
      do{
         copiavettore(vettore,temp,max);//Copio il vettore
         t++; //Incremento il contatore
        }while (t <=rip); //ripeto fino a quando il contatore è minore di rip
      float t_final = clock();
      return t_final - t_iniz;
   }

      

//------------------------------------------------------------------------
// Name : mis_temp  (Misurazione Tempo esecuzione)
// Desc : Questa Procedura richiama QuickSort e ne calcola l'effettivo tempo di esecuzione
//        Per fare cio prima stabilisco il tempo minimo di esecuzione (Tmin)
//        successivamente poi viene calcolato il numero minimo di ripetizioni
//        necessario affinche' il tempo di ordinamento sia abb. grande perke 
//        il minimo tempo misurabile dal OS è relativamente grande.
//        La funzione torna il valore del tempo necessario per ordinare rip
//        volte il vettore
// ToDo : Implementare Heap Sort e Insortion Sort
// Bugs : Nothing ;)
//-------------------------------------------------------------------------



float mis_temp(int max,float t0,float t1,float taratot,float T_parziale_QS,float T_parziale,float T_parziale_HS,float T_parziale_IS){
                            int t = 0;//Contatore ripetizioni
                            int rip = 0; // Contatore del numero di ripetizione
                            float tempo_tot = 0;
                            //Dichiaro le Costanti
                            //Dichiaro le variabili
                            long vettore [max];//inizializzo il vettore
                            long tempor [max];//inizializzo il vettore di backup
                            float Tmin = Tminimo(5);
                            //----- Implemento il vettore con elementi generati casualmente
                            for (int i=0; i<=max;i++)
                            vettore[i] =(long)( Random()*500000);
                            //----------- Calcolo Ripetizioni ------------------------------------
                            //Calcolo il minimo numero di ripetizioni per far si ke la durata di esecuz sia maggiore
                            //della precisione dell orologio e assegno a rip il numero delle ripetizioni
                            rip = Ripetizioni(vettore,tempor,max,Tmin);
                            copiavettore (vettore,tempor,max);//Faccio una copia di backup del vettore
                            
                            //ripeto l'algoritmo una quantita di volte pari a rip
                          //--------------ESEGUO QUICKSORT------------------
                          if (modalita == 1){
                           t0 = clock();//inizio a contare la durata dell'algoritmo            
                            do{
                               QuickSort(vettore,0,(max - 1)); // richiamo QuickSort
                               t++; //incremento il contatore
                               copiavettore(tempor,vettore,max); //copio il vettore disordinato in quello appena ordinato
                              }while (t<=rip); //ripetizioni
                             t1 = clock(); //Cronometro il tempo finale 
                             buffer2="ALGORITMO QUICKSORT";
                             }//end if 1
                           //-------------ESEGUO HEAPSORT-------------------  
                            if (modalita == 2){
                             t0 = clock();//inizio a contare la durata dell'algoritmo            
                             do{
                               // insertionsort(vettore,max); // richiamo QuickSort
                                t++; //incremento il contatore
                                copiavettore(tempor,vettore,max); //copio il vettore disordinato in quello appena ordinato
                               }while (t<=rip); //ripetizioni
                              t1 = clock(); //Cronometro il tempo finale 
                              buffer2="ALGORITMO HEAPSORT";
                              }//end if 2
                           //------------ESEGUO INSERTIONSORT------------------   
                            if (modalita == 3){
                              t0 = clock();            
                             //inizio a contare la durata dell'algoritmo            
                             do{
                                     
                                InsertionSort(vettore,max); // richiamo InserionSort
                                t++; //incremento il contatore
                                copiavettore(tempor,vettore,max); //copio il vettore disordinato in quello appena ordinato
                               }while (t<=rip); //ripetizioni
                              t1 = clock(); //Cronometro il tempo finale 
                              buffer2="ALGORITMO INSERTIONSORT";
                             }//end if 3
        //-----------------------------ESEGUI TUTTI E TRE------------------------------- 
                            if (modalita == 4){
                               t0 = clock();           
                              do{//------------------ESEGUO PER QUICK SORT
                                //float t0QS = clock()
                                QuickSort(vettore,0,(max - 1)); // richiamo QuickSor
                                t++; //incremento il contatore
                                copiavettore(tempor,vettore,max); //copio il vettore disordinato in quello appena ordinato
                                }while (t<=rip); //ripetizioni
                               t1 =clock();   
                               T_parziale_QS = t1 - t0;  //tempo parziale = tempo necessario affinche venga eseguito QuickSort n volte + la tara       
                              t=0;//reinizializzo a 0 il contatore
                              do{//------------------ESEGUO PER INSERTIONSORT
                                //float t0QS = clock()
                                InsertionSort(vettore,max); // richiamo QuickSor
                                t++; //incremento il contatore
                                copiavettore(tempor,vettore,max); //copio il vettore disordinato in quello appena ordinato
                                }while (t<=rip); //ripetizioni
                               t2 = clock();
                               T_parziale_IS = t2 - t1; //tempo parziale = tempo necessario affinche venga eseguito insertionsort n volte + la tara
                             }//End if 4
                            
                            
        //-----------------------------calcola TARA-----------------------------
                             if (modalita!=4){
                                T_parziale = t1 - t0;
                                taratot = Tara(vettore,tempor,max,rip); // calcolo la tara
                                ripetizioni = rip; //Memorizza in una variabile Globale il valore appena ottenuto delle ripetizioni
                                tempo_tot = T_parziale - taratot;//tempo tot
                              }
                             else{
                                  tempo_tot_campione_QS = 0;//il tempo totale di un campione lo inizializzo a 0
                                  tempo_tot_campione_IS = 0;//il tempo totale di un campione lo inizializzo a 0
                                  taratot = Tara(vettore,tempor,max,rip); // calcolo la tara
                                  ripetizioni = rip; //Memorizza in una variabile Globale il valore appena ottenuto delle ripetizioni
                                  tempo_tot_campione_QS = tempo_tot_campione_QS + (T_parziale_QS - taratot);//tempo totale di n ripetizioni per n campioni
                                  tempo_tot_campione_IS = tempo_tot_campione_IS + (T_parziale_IS - taratot);//tempo totale di n ripetizioni per n campioni

                             }
                       return tempo_tot;
                 }//End mis_temp
///////////////////////////////////////////////////////////////////////////////////////
////                     SAVE TO FILE & SCRITTURA A SCHERMO                       ////   
//////////////////////////////////////////////////////////////////////////////////////                
                 
void save_file (float media,float tot,int input,int ripetizioni,FILE *file,char array[5]){
   
   if ((file = fopen(array, "a"))==NULL) {//VErifica se si puo aprire il file
         puts("\nImpossibile aprire il file.\n");
 		 exit(1); }//Se non si puo assegna a errore il valore falso
 		else
        fprintf(file,"%d %.15f %d\n",input,media,ripetizioni);//sualva su file la media
        fclose(file);//chiudi file
    	
}

void stndout(int input,int scelta,float media,float tot,char * buffer2){
        //system ("cls");//pulisci schermo
        std::cout<<std::endl;
        std::cout<<buffer2;
        std::cout<<std::endl<<"Tempo stimato per ordinare "<<ripetizioni<<" volte un vettore lungo "<<input<<" elem. e':"<<tot<<" sec"<<std::endl;//Stampo il tempo di esecuzione
    	std::cout<<"Il tempo medio per Ordinare un vettore di lunghezza "<<input<<" e' "<<media<<" sec"<<std::endl;
    	std::cout<<std::endl;
} 
				 
/////////////////////////////////////////////////////////////////////////////////////
////                       PROGRAMMA PRINCIPALE                                  ////   
/////////////////////////////////////////////////////////////////////////////////////
//------------------------------------------
// Name : main 
// Desc : Programma Principale
// ToDo : Completo 
// Bugs : N.P
// Vers : 0.9 
//------------------------------------

int main () {
    float T_parziale = 0;
  
    float taratot = 0; //la grandezza della tara
    int scelta = 0; //variabile ke memorizza il valore scelto dall'utente nella GUI
    float media = 0;//Variabile che memorizza il tempo medio
    float tot = 0;  //tempo totale T_parizale - taratotale
    int input = 0;  // variabile ke memorizza la lunghezza del vettore
    bool errore = true;

//------   Dichiarazione FILE ----------
    FILE *file;
//---    
    seed = 123456789;  //inizializzazione seme
//-----INTESTAZIONE GUI------------

     std::cout<<std::endl;
     std::cout<<"Program : QuickSort Created by Valerio Bignardi & Andrea Babuin"<<std::endl;
     std::cout<<std::endl;
     std::cout<<"Algoritmi di Ordinamento di vettori "<<std::endl;
     std::cout<<"QuickSort"<<std::endl;
     std::cout<<"HeapSort"<<std::endl;
     std::cout<<"InsertionSort"<<std::endl;
     std::cout<<std::endl;
     std::cout<<"Universita' Agli Studi di Udine 2004/2005 "<<std::endl;
     std::cout<<"Scegliere l'algorimo: "<<std::endl;
     std::cout<<std::endl;
    // ---  Richiamo la funzione QuickSort
    // ---  Implemento il calcolo temporale di esecuzione dell'algoritmo QuickSort
    // Per eseguire tale operazione devo a priori calcolare la precisione dell'orologio
    // di sistema,per fare cio' basta implementare questo codice:
          /*int main()
               {
                float t0 = clock();
                float t1 = clock();
                while (t0 == t1)
                t1 = clock();
                float tot = (t1 - t0)/CLOCKS_PER_SEC;
                return 0;
               }*/
    // il valore risultante è 15 ms. di conseguenza il tempo minimo misurabile con
    // errore massimo del 5% è dato da:
    //  errore tollerato : 100 = precisione orologio : minimo tempo misurab. x
    // quindi x = (100 * precisione orologio) / 5% 
    // ke nel nostro caso è: (100 * 15) / 5 quindi x = 300 ms
  do{ 
	scelta = menu();//assegno a scelta il valore scelto dall'utente
    switch(scelta){
                      case 1:{  
                              const int max = 10;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                              tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                              tot = tot / 500;
                             };break;  
                      case 2:{
                              const int max = 20;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                               tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                              tot = tot / 500;
                             };break;  
                      case 3:{
                              const int max = 50;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                               tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                              tot = tot / 500;
                             };break;  
                      case 4:{
                               const int max = 100;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                               tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                             tot = tot / 500;
                             };break;  
                      case 5:{
                              const int max = 200;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                               tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                             tot = tot / 500;
                             };break;  
                      case 6:{
                              const int max = 500;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                               tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                              tot = tot / 500;
                             };break;  
                      case 7:{
                               const int max = 1000;//inializzo la lunghezza del vettore
                              input=max;
                              for (int j=0;j<500;j++) 
                             tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                              tot = tot / 500;
                             };break;  
                      case 8:{
                              const int max = 5000;//inializzo la lunghezza del vettore
                              input=max;
                            for (int j=0;j<500;j++) 
                               tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);
                            tot = tot / 500;
                             };break;   
                      case 9:{
                              int vett[7];
                              int input = 0;
                              //------Inizializzo il vettore
                              vett[0]=10;
                              vett[1]=20;
                              vett[2]=50;
                              vett[3]=100;
                              vett[4]=200;
                              vett[5]=500;
                              vett[6]=1000;
                              vett[7]=5000;
                             if (modalita!=4){//se non ho selezionato di fare tutti e tre gli algoritmi insieme
                              for (int j=0;j<8;j++){//ripeti per tutti e 8 le lunghezze di input
                                   input = vett[j];//assegna ad input la lunghezza del vettore
                                   tot = 0;
                                   for(int k=0;k<500;k++)//ripeti per 500 campioni differenti
                                   tot = tot + mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);//assegna il tempo totale di esecuzione dell'algoritmo scelto
                                   tot = (tot/500)/CLOCKS_PER_SEC;//dividi per il numero di campioni e per la costante di clock
                                   media = (tot / ripetizioni);//calcolo la media del tempo necessario per ordinare un solo vettore 1 sola volta
                                   stndout(input,scelta,media,tot,buffer2);//stampa a schermo i risultati}
                                   save_file (media,tot,input,ripetizioni,file,buffer);//Salva su file il tempo medio per poi compararlo con gli altri algoritmi e input
                               } //end for
                              }//end if
                             else//SE ho selezionato la modalita 4 (modalita 4 = esegue tutti e tre gli algoritmi)
                              {
                               for (int j=0;j<8;j++){
                                input = vett[j];
                                tot = 0;
                                for(int k=0;k<500;k++){//ripeti per 500 vettori differenti
                                  mis_temp(input,t0,t1,taratot,T_parziale,T_parziale_QS,T_parziale_HS,T_parziale_IS);//Calcolo i tempi Totali per eseguire tot ripetizioni di 1 campione
                                  tempo_tot_QS = tempo_tot_QS + tempo_tot_campione_QS; //Sommo i tempi totali di 500 campioni di QuickSort
                                  tempo_tot_IS = tempo_tot_IS + tempo_tot_campione_IS; //Sommo i tempo totali di 500 campioni di Insortion Sort
                                }//end for 0 to 500
                                tempo_tot_QS = tempo_tot_QS /(CLOCKS_PER_SEC * 500); //Trovo il tempo medio di un campione
                                tempo_tot_IS = tempo_tot_IS /(CLOCKS_PER_SEC * 500); //trovo il tempo medio di un camione
                                media_QS = (tempo_tot_QS / (ripetizioni));//trovo il tempo medio di un solo ordinameno
                                media_IS = (tempo_tot_IS / (ripetizioni));//Trovo il tempo medio di un solo ordinamento
                                stndout(input,scelta,media_QS,tempo_tot_QS,"ALGORITMO QUICKSORT");//Stampa i risultati a video
                                stndout(input,scelta,media_IS,tempo_tot_IS,"ALGORITMO INSERTIONSORT");//Stampa i risultati a video
                                save_file (media,tempo_tot_QS,input,ripetizioni,file,buffer);//Salva su file il tempo medio 
                                save_file (media,tempo_tot_IS,input,ripetizioni,file,buffer);//Salva su file il tempo medio 
                               }//end for 0 to 8                                                                                                                                                            );//stampa a schermo i risultati}
                             }//End else               
					  };break;//end case
                   
                  case 0:{std::cout<<"FINE"<<std::endl;
                       exit (0);//esci da programma
					   };break;
                   }//end switch                   
       if (scelta != 9 && scelta!=0){//Se non sono nel caso 9 e 0 allora esegui altrimenti termina il programma
        tot = tot /CLOCKS_PER_SEC;//calcolo il tempo di esecuzione
        media = (tot / ripetizioni);    //Calcola la media
      // #ifdef LINUX
        stndout(input,scelta,media,tot,buffer2);//stampa a schermo i risultati
        save_file (media,tot,input,ripetizioni,file,buffer);//Salva su file il tempo medio per poi compararlo con gli altri algoritmi e input
      }//End if
  }while (!(scelta == 0));  	//Ripeto fino a quando la gui non mi restitusce valore 0

	//exit with code 0
        
    	return 0;
    	

}//end main


-----------------------PEZZO DI CODICE BUGGATO-----------------



#include <iostream>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>
#define A 16087
#define M 2147483647
#define Q 127773
#define R 2836
int max = 10;
long vett[10];

double seed;
long HeapSize;
long left(long i)
{
	return 2*i+1;
}


long right(long i)
{
	return 2*i+2;
}


long p(long i)
{
	return (i-1)/2;
}





void swap (long& a, long& b) {
	a = b + a; //      (a+b)          b
	b = a - b; //      (a+b)        (a+b)-b
	a = a - b; //      (a+b)-a        a
};

double Random()
{
   double lo, hi, test;
   hi = ceil(seed / Q);
   lo = seed - Q * hi;
   test = A * lo - R * hi;
   if (test < 0.0) {
      seed = test + M;
   } else {
      seed = test;
   } /* endif */
   return seed / M;
} //end random

void Heapify(long* vett,long i){
     long l = left(i);
     long r = right(i); //QUA IL DEBUG da err. do SEGMENTAZIONE
     long largest;
     if (l <= HeapSize && vett[l] > vett[i])
      largest = l;
     else 
      largest = i;
     if (r<=HeapSize && vett[r] > vett[largest])
      largest = r;
     if (largest != i)
      swap(vett[i],vett[largest]);
     Heapify(vett,largest);
}
void BuildHeap (long* vett){
     HeapSize = max;   
     for (int i=max/2; i>=0; i--)
		Heapify(vett, i);
}

void HeapSort(long  vett[])
{
	BuildHeap(vett);
	long zero = 0;
	for (int i=max-1; i>=1; i--) {
		swap(zero,vett[i]);
		HeapSize--;
		Heapify(vett, 0);
	}
}

int main(){
    seed =123456789;
    
  
    for (int k=0; k<=max;k++)
    vett[k] =(long)( Random()*20);
    HeapSort(vett);
    for (int l = 0;l<max;l++)
    std::cout<<vett[l]<<std::endl;
    int n = 0;
    std::cin>>n;
}

SU questa stringa:
long r = right(i); //QUA IL DEBUG da err. do SEGMENTAZIONE
nella void HEAPIFY mi da errore


Grazie in anticipo per l'aiuto

[cionci]

I buffer vanno allocati prima die ssere utilizzati... Inoltre una stringa non si valorizza così: buffer = "HS.txt";

Ma così: strcpy(buffer, "HS.txt");

Appena ho visto i buffer non dimensionati ho subito cercato se c'era una malloc o una calloc nel codice, ma non l'ho trovata...

[tglman]

Secondo me le stringhe vanno bene, i buffer cosi dichiarati non sono vettori ma puntatori, e quindi puoi utilizzarli in 2 modi uno e allocando dinamicamente la memoria con malloc per pio copiarci dentro la stringa con strcpy ed un'altro è proprio quello usato nel codice che indica che quel puntatore punta alla stringa inserita tra apici...

Fare un char * cc="ciao";
si puo definire uguale ad un printf("ciao");
solo che nel secondo l'indirizzo viene passoto alla funzione e non copiato in una variabile...

Secondo me controlla bene il codice ed evita di utilizzare nomi di variabili uguali alle nomi delle funzioni, anche per variabili interne ad funzioni, per esempio la parola right e usata sia per alcune variabili interne a funzioni sia per la funzione (a meno che il codice che hai scritto non stia su file diversi)

Ciao...

[cionci]

Originariamente inviato da tglman
Fare un char * cc="ciao";
si puo definire uguale ad un printf("ciao");
solo che nel secondo l'indirizzo viene passoto alla funzione e non copiato in una variabile...

Questo utilizzo è buono...ma siamo sicuri che l'abbia utilzzati solo in questo modo ? Ora io non ho controllato tutto, ma siamo sicuri che l'ha usati solo in questo modo ? Ora guardo meglio...certo una indentata del codice avrebbe dato una mano...edito il post sopra per indentarlo...

[cionci]

Sembra che siano stati usati tutti così...

[tglman]

Inoltre invece di utilizzare delle funzioni, per fare operazioni cosi semplici ti conviene creare delle macro...

Ciao...