[C++] ocena/pomiar sortowania - prosba o poprawki

0

Witam,

Mój problem polega na tym, że program się sypie, gdy próbuję wykonać pomiary.
Wydaje mi się, że chodzi o alokacje/zwolnienie pamięci, ale nie mogę nic wykombinować i proszę o pomoc.
Tylko 1 opcja w menu działa bez zarzutu... no i 7.

Oto kod:

#include <cstdlib>
#include <time.h>
#include <iostream>

using namespace std;


void insertion(int *tablica, int rozmiar)
{
     int i, j, temp;
     for (i=1; i<rozmiar; i++)
     {
          temp=tablica[i];
          j=i;
          while (j>0 && tablica[j-1]>temp)
          {
               tablica[j]=tablica[--j];
          }
          tablica[j]=temp;
     }         
}

void selection(int *tablica, int rozmiar)
{
     int i, j, index, temp;
     for (i=0; i<rozmiar-1; i++)
     {
          index=i;
          for (j=i+1; j<rozmiar; j++)
               if (tablica[j]<tablica[index])
                    index=j;
          if (index!=i)      
          {                 
               temp=tablica[i];      
               tablica[i]=tablica[index];    
               tablica[index]=temp;   
          }                 
     }
}

void heapify(int *tablica, int x, int rozmiar)
{
     int lewy=2*x+1, prawy=lewy+1, max=x;
     if (lewy<=rozmiar && tablica[lewy]>tablica[max])
          max=lewy;
     if (prawy<=rozmiar && tablica[prawy]>tablica[max])
          max=prawy;
     if (max!=x)
     {
          int temp=tablica[x];
          tablica[x]=tablica[max];
          tablica[max]=temp;
          heapify(tablica,max,rozmiar);
     }
}

void heap(int *tablica, int rozmiar)
{
     int i, temp;
     rozmiar--;               
     for (i=rozmiar/2; i>=0; i--)
          heapify(tablica,i,rozmiar);
     for (i=rozmiar; i>0; i--)
     {
          temp=tablica[0];
          tablica[0]=tablica[i];
          tablica[i]=temp;
          heapify(tablica,0,i-1);
     }
}


void quicksort(int *tablica, int x, int y)
{
     int i=x, j=y, mediana=tablica[(x+y)/2], temp;
     while (j>=i)
     {
          while (tablica[i] < mediana)
          i++;
               while (tablica[j] > mediana)
                    j--;
               if (i<=j)
               {
                    temp=tablica[i];
                    tablica[i++]=tablica[j];
                    tablica[j--]=temp;
               }
     }
     if (x<j)
          quicksort(tablica,x,j);
     if (i<y)
          quicksort(tablica,i,y);
}

void ciag_l(int *tablica, int rozmiar)
{
     int i;
     for (i = 0; i < rozmiar; ++i)
     {
          tablica[i] = rand() % rozmiar;
     }
}

void ciag_r(int *tablica, int rozmiar)
{
     int i;
     tablica[0] = 1;
     for (i = 1; i < rozmiar; ++i)
     {
          tablica[i] = tablica[i-1] + 1;
     }
}

void ciag_m(int *tablica, int rozmiar)
{
     int i;
     tablica[0] = rozmiar;
     for (i = 1; i < rozmiar; ++i)
     {
          tablica[i] = tablica[i-1]-1;
     }
}

void ciag_s(int *tablica, int rozmiar)
{
     int i;
     for (i = 0; i < rozmiar; ++i)
     {
          tablica [i] = 1;
     }
}

void ciag_v(int *tablica, int rozmiar)
{
     int przyrost = rozmiar/2;
     int licznik = 1;
     int i, x = 1;
     tablica[przyrost] = 1;
     while(licznik < rozmiar)
     {
          if(przyrost - x >= 0)
               tablica[przyrost - x] = ++licznik;
          if(przyrost + x < rozmiar)
               tablica[przyrost + x++] = ++licznik;
     }      
}

    

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

   int menu, i, rozmiar, *tablica;
   int elementy[27]={10,100,1000,2500,5000,6000,7000,8000,9000,
10000,12500,25000,37500,50000,62500,75000,87500,100000,150000,
200000,400000,800000,1000000,2000000,4000000,8000000,10000000};
   int y;
   float czas1 = 0, czas2 = 0, czas3 = 0, czas4 = 0;
   time_t t;
   srand((unsigned) time(&t));
   bool over1 = false, over2 = false, over3 = false, over4 = false;
                       //tablica = new int[rozmiar];
    
    
   
   do
   {  
        do
        {
             cout << "WYBIERZ OPCJE: "                << endl
                  << "1 - Prezentacja sortowan"       << endl
                  << "2 - Test 1 - ciagi losowe"      << endl
                  << "3 - Test 2 - ciagi rosnace"     << endl
                  << "4 - Test 3 - ciagi malejace"    << endl
                  << "5 - Test 4 - ciagi stale"       << endl
                  << "6 - Test 5 - ciagi v-ksztaltne" << endl
                  << "7 - Zakoncz program"            << endl;
             cin  >> menu;
        }
        while(menu == 0 || menu > 7);

        switch(menu)
        {
             case 1:
             {
                  cout << "------------------ PREZENTACJA SORTOWAN -----------------"
                       << endl << endl;
                  tablica = new int[rozmiar];
                  rozmiar = 20;
                  cout << "INSERTION SORT: " << endl << endl;
                  ciag_l(tablica, rozmiar);
                  cout << "Ciag losowy:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  insertion(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_r(tablica, rozmiar);
                  cout << "Ciag rosnacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  insertion(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_m(tablica, rozmiar);
                  cout << "Ciag malejacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  insertion(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_s(tablica, rozmiar);
                  cout << "Ciag staly:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  insertion(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_v(tablica, rozmiar);
                  cout << "Ciag v-ksztaltny:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  insertion(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl << endl;
//------------------------------------------------------------------------------                  
                  cout << "SELECTION SORT: " << endl << endl;
                  ciag_l(tablica, rozmiar);
                  cout << "Ciag losowy:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  selection(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_r(tablica, rozmiar);
                  cout << "Ciag rosnacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  selection(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_m(tablica, rozmiar);
                  cout << "Ciag malejacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  selection(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_s(tablica, rozmiar);
                  cout << "Ciag staly:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  selection(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_v(tablica, rozmiar);
                  cout << "Ciag v-ksztaltny:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  selection(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl << endl;
//------------------------------------------------------------------------------
                  cout << "HEAP SORT: " << endl << endl;
                  ciag_l(tablica, rozmiar);
                  cout << "Ciag losowy:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  heap(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_r(tablica, rozmiar);
                  cout << "Ciag rosnacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  heap(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_m(tablica, rozmiar);
                  cout << "Ciag malejacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  heap(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_s(tablica, rozmiar);
                  cout << "Ciag staly:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  heap(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_v(tablica, rozmiar);
                  cout << "Ciag v-ksztaltny:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  heap(tablica, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl << endl;
//------------------------------------------------------------------------------                  
                  cout << "QUICK SORT: " << endl << endl;
                  ciag_l(tablica, rozmiar);
                  cout << "Ciag losowy:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  quicksort(tablica, 0, rozmiar-1);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_r(tablica, rozmiar);
                  cout << "Ciag rosnacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  quicksort(tablica, 0, rozmiar-1);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_m(tablica, rozmiar);
                  cout << "Ciag malejacy:" << endl;
                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  quicksort(tablica, 0, rozmiar-1);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_s(tablica, rozmiar);
                  cout << "Ciag staly:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  quicksort(tablica, 0, rozmiar);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  ciag_v(tablica, rozmiar);
                  cout << "Ciag v-ksztaltny:" << endl;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl;
                  quicksort(tablica, 0, rozmiar-1);
                  cout << "Posortowany:" << endl;;
                  for (i = 0; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }
                  cout << endl << endl;
             }
             break;
             
             case 2:
             {
                  cout << "Test 1 - CIAGI LOSOWE:" << endl;
                  for(i=0; i<27; i++)
                  {    
                       //tablica = new int[rozmiar];
                       rozmiar = elementy[i];
                       tablica = new int[rozmiar];
                       if(czas1 >= 15)
                       {
                            over1 = true;
                            czas1 = 0;
                       }
                       if(over1 == false) 
                       {
                            ciag_l(tablica, rozmiar);
                            czas1=clock();
                            insertion(tablica, rozmiar);
                            czas1=clock()-czas1;
                            czas1/=CLOCKS_PER_SEC;
                       }
                       cout << "IS: " << czas1 << "s || ";
                       if(czas2 >= 15)
                       {
                            over2 = true;
                            czas2 = 0;
                       }
                       if(over2 == false)
                       {        
                            ciag_l(tablica, rozmiar);
                            czas2=clock();
                            selection(tablica, rozmiar);
                            czas2=clock()-czas2;
                            czas2/=CLOCKS_PER_SEC;
                       }
                       cout << "SS: " << czas2 << "s || ";
                       if(czas3 >= 15)
                       {
                            over3 = true;
                            czas3 = 0;
                       }
                       if(over3 == false)
                       {
                            ciag_l(tablica, rozmiar);
                            czas3=clock();
                            heap(tablica, rozmiar);
                            czas3=clock()-czas3;
                            czas3/=CLOCKS_PER_SEC;
                       }
                       cout << "HS: " << czas3 << "s || ";
                       if(czas4 >= 15)
                       {
                            over4 = true;
                            czas4 = 0;
                       }
                       if(over4 == false)
                       {
                            ciag_l(tablica, rozmiar);
                            czas4=clock();
                            quicksort(tablica, 0, rozmiar-1); 
                            czas4=clock()-czas4;
                            czas4/=CLOCKS_PER_SEC;   
                       }
                       cout << "QS: " << czas4 << "s || ";
                       cout << "n = " << rozmiar << endl;
                  }
                  cout << endl;
             }
             break;
             
             case 3:
             {
                  cout << "Test 1 - CIAGI ROSNACE:" << endl;
                  for(i=0; i<27; i++)
                  {    
                       //tablica = new int[rozmiar];
                       rozmiar = elementy[i];
                       tablica = new int[rozmiar];
                       if(czas1 >= 15)
                       {
                            over1 = true;
                            czas1 = 0;
                       }
                       if(over1 == false) 
                       {
                            ciag_r(tablica, rozmiar);
                            czas1=clock();
                            insertion(tablica, rozmiar);
                            czas1=clock()-czas1;
                            czas1/=CLOCKS_PER_SEC;
                       }
                       cout << "IS: " << czas1 << "s || ";
                       if(czas2 >= 15)
                       {
                            over2 = true;
                            czas2 = 0;
                       }
                       if(over2 == false)
                       {        
                            ciag_r(tablica, rozmiar);
                            czas2=clock();
                            selection(tablica, rozmiar);
                            czas2=clock()-czas2;
                            czas2/=CLOCKS_PER_SEC;
                       }
                       cout << "SS: " << czas2 << "s || ";
                       if(czas3 >= 15)
                       {
                            over3 = true;
                            czas3 = 0;
                       }
                       if(over3 == false)
                       {
                            ciag_r(tablica, rozmiar);
                            czas3=clock();
                            heap(tablica, rozmiar);
                            czas3=clock()-czas3;
                            czas3/=CLOCKS_PER_SEC;
                       }
                       cout << "HS: " << czas3 << "s || ";
                       if(czas4 >= 15)
                       {
                            over4 = true;
                            czas4 = 0;
                       }
                       if(over4 == false)
                       {
                            ciag_r(tablica, rozmiar);
                            czas4=clock();
                            quicksort(tablica, 0, rozmiar-1);  
                            czas4=clock()-czas4;
                            czas4/=CLOCKS_PER_SEC;   
                       }
                       cout << "QS: " << czas4 << "s || ";
                       cout << "n = " << rozmiar << endl;
                  }
                  cout << endl;
             }
             break;
             
             case 4:
             {    
                  cout << "Test 1 - CIAGI MALEJACE:" << endl;
                  for(i=0; i<27; i++)
                  {    
                       rozmiar = elementy[i];
                       tablica = new int[rozmiar];
                       if(czas1 >= 15)
                       {
                            over1 = true;
                            czas1 = 0;
                       }
                       if(over1 == false) 
                       {
                            ciag_m(tablica, rozmiar);
                            czas1=clock();
                            insertion(tablica, rozmiar);
                            czas1=clock()-czas1;
                            czas1/=CLOCKS_PER_SEC;
                       }
                       cout << "IS: " << czas1 << "s || ";
                       if(czas2 >= 15)
                       {
                            over2 = true;
                            czas2 = 0;
                       }
                       if(over2 == false)
                       {        
                            ciag_m(tablica, rozmiar);
                            czas2=clock();
                            selection(tablica, rozmiar);
                            czas2=clock()-czas2;
                            czas2/=CLOCKS_PER_SEC;
                       }
                       cout << "SS: " << czas2 << "s || ";
                       if(czas3 >= 15)
                       {
                            over3 = true;
                            czas3 = 0;
                       }
                       if(over3 == false)
                       {
                            ciag_m(tablica, rozmiar);
                            czas3=clock();
                            heap(tablica, rozmiar);
                            czas3=clock()-czas3;
                            czas3/=CLOCKS_PER_SEC;
                       }
                       cout << "HS: " << czas3 << "s || ";
                       if(czas4 >= 15)
                       {
                            over4 = true;
                            czas4 = 0;
                       }
                       if(over4 == false)
                       {
                            ciag_m(tablica, rozmiar);
                            czas4=clock();
                            quicksort(tablica, 0, rozmiar-1);
                            czas4=clock()-czas4;
                            czas4/=CLOCKS_PER_SEC;   
                       }
                       cout << "QS: " << czas4 << "s || ";
                       cout << "n = " << rozmiar << endl;
                  }
                  cout << endl;
             }
             break;
             
             case 5:
             {
                  cout << "Test 1 - CIAGI STALE:" << endl;
                  for(i=0; i<27; i++)
                  {    
                       rozmiar = elementy[i];
                       tablica = new int[rozmiar];
                       if(czas1 >= 15)
                       {
                            over1 = true;
                            czas1 = 0;
                       }
                       if(over1 == false) 
                       {
                            ciag_s(tablica, rozmiar);
                            czas1=clock();
                            insertion(tablica, rozmiar);
                            czas1=clock()-czas1;
                            czas1/=CLOCKS_PER_SEC;
                       }
                       cout << "IS: " << czas1 << "s || ";
                       if(czas2 >= 15)
                       {
                            over2 = true;
                            czas2 = 0;
                       }
                       if(over2 == false)
                       {        
                            ciag_s(tablica, rozmiar);
                            czas2=clock();
                            selection(tablica, rozmiar);
                            czas2=clock()-czas2;
                            czas2/=CLOCKS_PER_SEC;
                       }
                       cout << "SS: " << czas2 << "s || ";
                       if(czas3 >= 15)
                       {
                            over3 = true;
                            czas3 = 0;
                       }
                       if(over3 == false)
                       {
                            ciag_s(tablica, rozmiar);
                            czas3=clock();
                            heap(tablica, rozmiar);
                            czas3=clock()-czas3;
                            czas3/=CLOCKS_PER_SEC;
                       }
                       cout << "HS: " << czas3 << "s || ";
                       if(czas4 >= 15)
                       {
                            over4 = true;
                            czas4 = 0;
                       }
                       if(over4 == false)
                       {
                            ciag_s(tablica, rozmiar);
                            czas4=clock();
                            quicksort(tablica, 0, rozmiar-1);
                            czas4=clock()-czas4;
                            czas4/=CLOCKS_PER_SEC;   
                       }
                       cout << "QS: " << czas4 << "s || ";
                       cout << "n = " << rozmiar << endl;
                  }
                  cout << endl;
             }
             break;
             
             case 6:
             {
                  cout << "Test 1 - CIAGI V-KSZTALTNE:" << endl;
                  for(i=0; i<27; i++)
                  {    
                       rozmiar = elementy[i];
                       tablica = new int[rozmiar];
                       if(czas1 >= 15)
                       {
                            over1 = true;
                            czas1 = 0;
                       }
                       if(over1 == false) 
                       {
                            ciag_v(tablica, rozmiar);
                            czas1=clock();
                            insertion(tablica, rozmiar);
                            czas1=clock()-czas1;
                            czas1/=CLOCKS_PER_SEC;
                       }
                       cout << "IS: " << czas1 << "s || ";
                       if(czas2 >= 15)
                       {
                            over2 = true;
                            czas2 = 0;
                       }
                       if(over2 == false)
                       {        
                            ciag_v(tablica, rozmiar);
                            czas2=clock();
                            selection(tablica, rozmiar);
                            czas2=clock()-czas2;
                            czas2/=CLOCKS_PER_SEC;
                       }
                       cout << "SS: " << czas2 << "s || ";
                       if(czas3 >= 15)
                       {
                            over3 = true;
                            czas3 = 0;
                       }
                       if(over3 == false)
                       {
                            ciag_v(tablica, rozmiar);
                            czas3=clock();
                            heap(tablica, rozmiar);
                            czas3=clock()-czas3;
                            czas3/=CLOCKS_PER_SEC;
                       }
                       cout << "HS: " << czas3 << "s || ";
                       if(czas4 >= 15)
                       {
                            over4 = true;
                            czas4 = 0;
                       }
                       if(over4 == false)
                       {
                            ciag_v(tablica, rozmiar);
                            czas4=clock();
                            quicksort(tablica, 0, rozmiar-1);
                            czas4=clock()-czas4;
                            czas4/=CLOCKS_PER_SEC;   
                       }
                       cout << "QS: " << czas4 << "s || ";
                       cout << "n = " << rozmiar << endl;
                  }
                  cout << endl;
             }
             break;
             
             case 7:
             {
                  delete[] tablica;
                  return EXIT_SUCCESS;
             }
             break;
        }         
    }
    while(menu != 7); 
    
    
    
    system("PAUSE");
    return EXIT_SUCCESS;
}
0

Brawo. 847 linii kodu metodą copy-paste bez jednego komentarza i dopisek "nie działa".
Chcesz powiedzieć że napisałeś (skopiowałeś) to wszystko nie sprawdzając czy działa ani razu?
...

0

Owszem napisałem, komentarzy nie pisałem, bo w sortowaniach wszyscy zaznajomieni z językiem c++ chyba nie znajdą nic wyszukanego, podobnie zresztą w tworzeniu ciągów rosnących, malejących itp.
Jeżeli skopiowałem to, to chętnie zobaczę linka z identyczną pracą...

I tak nie działa, bo jak mówiłem... wydaje mi się, że coś z alokacją pamięci jest dla tej tablicy, w których robione są sortowania, czasami po wykonaniu kilka razy opcji nr 1, czyli prezentacji wszystkich sortowań, opcja nr 2 działa i wykonuje się do samego końca, inne niestety nie działają w ogóle...

Edit:
Dodam jeszcze, chociaż pewnie w Twoich (Shalom) oczach to nic nie zmieni, że nie pisałem (wg Ciebie kopiowałem) tego w ciągu 2-3 minut, tylko ok. tygodnia... więc chyba muszę mieć dość wolnego kompa, skoro tak długo zajmuje mu przeniesienie tekstu z neta/innej pracy do kompilatora.
I owszem sprawdzałem, czy działa, ale dla małych tablic... i jak pokazuje opcja nr 1 działa, coś jest nie tak przy dużych rozmiarach...

0

Mnie się bardzo podoba:

                  cout << tablica[0] << " ";
                  for (i = 1; i < rozmiar; ++i)
                  {
                       cout << tablica[i] << " ";
                  }

Zamiast powtarzających się fragmentów zrób jedną funkcje.

             case 7:
             {
                  delete[] tablica;
                  return EXIT_SUCCESS;
             }
             break;
        }         
    }
    while(menu != 7);
   
   
   
    system("PAUSE");
    return EXIT_SUCCESS;
} 

Jak dla mnie taka konstrukcja jest co najmniej dziwna.

//Edit:
Wydaje mi się, że Shalom'owi chodziło o to, że jeden fragment kodu kopiowałeś n-razy, na przykład pierwszy cytowany przeze mnie fragment

0

no faktycznie niepotrzebne dodatkowe linie tylko :) to musiało zostać, jak miałem jeszcze ciągi w mainie, a nie w osobnych procedurach
a widzisz może przyczynę "niedziałania"? bo w sumie na tym najbardziej mi zależy :)

Edit:
Przy wywołaniach quciksorta powinno być rozmiar-1 a nie rozmiar, już zmieniam w pierwszym poście...

0

Chyba nie bardzo zrozumiałeś. Nie chodzi mi o kopiowanie czyjegoś kodu, ale o kopiowanie wlasnego.
KAŻDA opcja twojego switcha wygląda INDENTYCZNIE. Różni się jedynie nagłówkiem oraz tym z której funkcji losujesz ciąg. Dalej KAŻDY zestaw instrukcji i komunikatów dla poszczególnych sortowań jest IDENTYCZNY, różni się jedynie nagłówkiem oraz funkcja sortującą.
Nie prościej było napisać funkcję testuj() która dostawałaby jako argument np. wskaźnik na funkcję generującą ciąg oraz nagłówek do wypisania. Ta funkcja generowałaby ciąg wg zadanej funkcji i wołałaby funkcję testujsortowanie() która jako argument dostawałaby wskaźnik na funkcję sortującą. Funkcja testujsortowanie() zawierałaby ten namiętnie skopiowany przez ciebie z 50 razy kawalek kodu. W ten sposób twoje 850 linijek zamieniłoby się w 150.

Programując nalezy myśleć, a nie klepać. Gdybyś miał teraz dodać do swojego programu jeden dodatkowy typ ciągu oraz jedno dodatkowe sortowanie to ile czasu by ci to zajęło? Bo gdybyś pisał to tak jak podałem przed chwilą to byłoby to dopisanie 2 linijek z wywołaniem funkcji...

Jesli chodzi o sam kod to:

 
tablica = new int[rozmiar];
rozmiar = 20;

kompilator nie krzyczy że używasz zmiennej o nieokreślonej wartości?

0

Z pewnością tu jest błąd:

                  for(i=0; i<27; i++)
                  {
                       rozmiar = elementy[i];
                       tablica = new int[rozmiar];

alokujesz tablicę 27 razy i ani razu jej nie zwalniasz.
Możesz zrobić łatwiej, tzn. zrobić od razu większą tablicę i używać tylko tej częsci, która jest CI potrzebna.
Zauważ, że każda opcja, która testuje, praktycznie niczym się nie różni. Możesz zrobić w ten sposób:
generujesz odpowiedni test i w osobnej funkcji robisz testowanie sortowań dla zadanego ciągu.

0

Ah to sorki za brak zrozumienia :)
Faktycznie byłoby to lepsze wyjście i chyba tak zrobie, jednak mimo wszystko chciałbym wiedzieć gdzie jest błąd.

Jeżeli chodzi o tą zmienną, to niby działa wszystko, ale faktycznie nawet źle to wygląda :)

Edit:

Dzięki za rady pokombinuje i jak coś dam znać :)
Dodam tylko, że przydzieliłem większy rozmiar tablicy, jak zalecał marseel i wszystko działa... pozostaje tylko "skrócić" program
Jeszcze raz dzięki :)

0

Mnie na Twoim miejscu nie dałby spokoju fakt, że alokuje dużą tablicę i nie wykorzystuję jej całej... oszczędzaj pamięć i używaj jej tyle ile potrzebujesz. Wykorzystaj do tych celów kontenery wbudowane w standardową bibliotekę albo lepiej jeszcze spróbuj sam opakować taką tablicę ( bądź stwórz własny kontener ) w klasę która zadbała by o rezerwowanie pamięci i jej zwalnianie.

1 użytkowników online, w tym zalogowanych: 0, gości: 1