Sortowanie w C

0

Cześć. Napisałem program sortujący tablice od 30tyś elementów do 300 tyś skok co 30tyś. Każdą taką tablicę wypełniam kolejnymi liczbami całkowitymi, liczbyami pseudolosowymi i pseudolosowymi z przedziału od 0 do 2.Czasy poszczególnych sortowań zapisuję do pliku tekstowego. Po uruchomieniu program wykonuje się bardzo długo (po ponad 30 minutach wyłączyłem więc nwm jak długo może mielić te tablice).W pliku tekstowym czasy sortowań wydają się być wiarygodne ,ale sortowanie doszło do tablicy 240tyś (brakuje dla 270tyś i 300 tyś)..Nie mam pojęcia co robię nie tak .Metody sortujące są ok, testowałem na kilku przykładach .Poniżej zamieszczam kod.

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

        void InsertSort(int tab[],int i){


     for(int j=1;j<i;++j){

            int k=j;
            int temp=tab[k];
            while((k>0)&&(tab[k-1]>temp)){

                  tab[k]=tab[k-1];
                  --k;

                  }
                    tab[k]=temp;
            }
            }

        void BubbleSort(int tab[],int i){

           for(int j=1;j<i;++j){

    for(int k=i-1;k>=j;--k){
                if(tab[k-1]>tab[k]){
                    int temp=tab[k];
                    tab[k]=tab[k-1];
                    tab[k-1]=temp;


                                    }


                            }

                                }




                                            }

        void QuickSort(int tab[], int lewy, int prawy){
	if(prawy <= lewy) return;

	int i = lewy - 1, j = prawy + 1,
	os = tab[(lewy+prawy)/2];

	while(1)
	{

		while(os>tab[++i]);


		while(os<tab[--j]);

		if( i <= j){
            int temp=tab[i];
            tab[i]=tab[j];
            tab[j]=temp;
            }

		else
			break;
	}

	if(j > lewy)
	QuickSort(tab, lewy, j);
	if(i < prawy)
	QuickSort(tab, i, prawy);
}

        void FlagBubbleSort(int tab[],int i){

           bool flaga=true;

           for(int j=1;j<i;++j){
            flaga=false;
        for(int k=i-1;k>=j;--k){
                if(tab[k-1]>tab[k]){
                     flaga=true;
                    int temp=tab[k];
                    tab[k]=tab[k-1];
                    tab[k-1]=temp;


                                    }
}

            if(flaga==false) break;
                                }




           }






int main()
{

    long start,stop;
    double czas;


    srand(time(NULL));
    FILE *f;
    f=fopen("Czasy.txt","w");
    for(int i=30000;i<=300000;i=i+30000){



        int* tab;
        tab =(int*) malloc(i * sizeof(int));

        int right=i-1;
        fprintf(f,"Tablica %d tysięcy \n\n",i);
        for(int j=0;j<i;++j){       //Zapelnienie tablicy kolejnymi liczbami calkowitymi zaczynajac od 1
        tab[j]=j+1;

        }
        fprintf(f,"Kolejne Liczby Całkowite \n ");
        start=clock();
        InsertSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"InsertSort_Czas:   %lf s \n ",czas);

        start=clock();
        BubbleSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"BubbleSort_Czas:   %lf s \n ",czas);

        start=clock();
        FlagBubbleSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"FlagBubbleSort_Czas:%lf s \n ",czas);

        start=clock();
        QuickSort(tab,0,right);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"QuickSort_Czas:     %lf s \n\n ",czas);









        for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi
        tab[j]=rand();

        }

        fprintf(f,"Liczby Pseudolosowe całkowite \n ");
        start=clock();
        InsertSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"InsertSort_Czas:   %lf s \n ",czas);

        for(int j=0;j<i;++j){
        tab[j]=rand();

        }

        start=clock();
        BubbleSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"BubbleSort_Czas:   %lf s \n ",czas);

        for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi
        tab[j]=rand();

        }

        start=clock();
        FlagBubbleSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"FlagBubbleSort_Czas:%lf s \n ",czas);

        for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi
        tab[j]=rand();

        }

        start=clock();
        QuickSort(tab,0,right);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"QuickSort_Czas:    %lf s \n\n ",czas);


        for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi z przedia³u od 0 do 2
        tab[j]=rand()%3;

        }

        fprintf(f,"Liczby pseudolosowe całkowite z przedzialu od 0 do 2 \n ");
        start=clock();
        InsertSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"InsertSort_Czas:   %lf s \n ",czas);

         for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi z przedia³u od 0 do 2
        tab[j]=rand()%3;

        }


        start=clock();
        BubbleSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"BubbleSort_Czas:   %lf s \n ",czas);

         for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi z przedia³u od 0 do 2
        tab[j]=rand()%3;

        }


        start=clock();
        FlagBubbleSort(tab,i);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"FlagBubbleSort_Czas:%lf s \n ",czas);

         for(int j=0;j<i;++j){       //Zapelnienie tablicy pseudolosowymi liczbami ca³kowitymi z przedia³u od 0 do 2
        tab[j]=rand()%3;

        }


        start=clock();
        QuickSort(tab,0,right);
        stop=clock();
        czas=(double)(stop-start)/CLOCKS_PER_SEC;
        fprintf(f,"QuickSort_Czas:      %lf s \n\n ",czas);



             free(tab);




    }

        fclose(f);



    return 0;
}
0

Zlozonosc Cie ubija, insertion sort jestO(n^2), co daje 240000*240000.

0

Nie czaję.Przetestowałem ten algorytm na tablicy 300tyś losowych liczb i wykonał się w 130sekund. Dlaczego w przypadku powyższego kodu złożoność miałaby być za duża ?

0

Dla każdego rozmiaru tablicy uruchamiasz 3 algorytmy o złożonośco O(n^2) dla 3 różnych konfiguracji danych. Uwzględniając to że masz 2 "korzystne" konfiguracje - możesz liczyć że uruchamiasz 7 kosztownych algorytmów. Na moim komputerze BubbleSort dla tablicy 180k trwa już ok. 90s.

0

Czyli rozumiem że mój kod nie zostanie wykonany do końca ze względu na zbyt dużą złożoność obliczeniową? Powinienem dla każdej metody sortowania stworzyć oddzielny program (a może dla każdej tablicy ) ?

1

Tak, pojedynczy algorytm i Zapodawaj mu, coraz większe rodzaje danych: losowe, posortowane malejąco i rosnąco i wszystkie równe. Zrobisz sobie tabelki i Będziesz miał jakąś wiedzę. Wrzuć to tutaj, to też coś się dowiemy.

1

W sumie - u mnie się właśnie wykonało...

Tablica 30000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.000253 s 
 BubbleSort_Czas:   1.011570 s 
 FlagBubbleSort_Czas:0.000067 s 
 QuickSort_Czas:     0.000903 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   0.578502 s 
 BubbleSort_Czas:   2.041584 s 
 FlagBubbleSort_Czas:2.091075 s 
 QuickSort_Czas:    0.003270 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   0.380301 s 
 BubbleSort_Czas:   1.859977 s 
 FlagBubbleSort_Czas:1.811186 s 
 QuickSort_Czas:      0.001431 s 

 Tablica 60000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.000268 s 
 BubbleSort_Czas:   4.066604 s 
 FlagBubbleSort_Czas:0.000147 s 
 QuickSort_Czas:     0.001970 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   2.352829 s 
 BubbleSort_Czas:   8.554362 s 
 FlagBubbleSort_Czas:8.846804 s 
 QuickSort_Czas:    0.007190 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   1.547864 s 
 BubbleSort_Czas:   8.027637 s 
 FlagBubbleSort_Czas:7.806450 s 
 QuickSort_Czas:      0.003042 s 

 Tablica 90000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.000446 s 
 BubbleSort_Czas:   9.113959 s 
 FlagBubbleSort_Czas:0.000198 s 
 QuickSort_Czas:     0.003006 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   7.672968 s 
 BubbleSort_Czas:   26.855448 s 
 FlagBubbleSort_Czas:24.347278 s 
 QuickSort_Czas:    0.011369 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   5.161008 s 
 BubbleSort_Czas:   22.805003 s 
 FlagBubbleSort_Czas:20.905861 s 
 QuickSort_Czas:      0.004842 s 

 Tablica 120000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.000551 s 
 BubbleSort_Czas:   16.444657 s 
 FlagBubbleSort_Czas:0.000270 s 
 QuickSort_Czas:     0.004129 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   15.748907 s 
 BubbleSort_Czas:   45.920481 s 
 FlagBubbleSort_Czas:40.303680 s 
 QuickSort_Czas:    0.014687 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   10.500327 s 
 BubbleSort_Czas:   39.802426 s 
 FlagBubbleSort_Czas:35.736373 s 
 QuickSort_Czas:      0.006850 s 

 Tablica 150000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.000743 s 
 BubbleSort_Czas:   26.189187 s 
 FlagBubbleSort_Czas:0.000336 s 
 QuickSort_Czas:     0.005303 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   25.385601 s 
 BubbleSort_Czas:   70.136238 s 
 FlagBubbleSort_Czas:62.365053 s 
 QuickSort_Czas:    0.019445 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   15.860161 s 
 BubbleSort_Czas:   62.379273 s 
 FlagBubbleSort_Czas:54.549205 s 
 QuickSort_Czas:      0.009221 s 

 Tablica 180000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.000898 s 
 BubbleSort_Czas:   37.351652 s 
 FlagBubbleSort_Czas:0.000401 s 
 QuickSort_Czas:     0.006533 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   36.937218 s 
 BubbleSort_Czas:   97.789914 s 
 FlagBubbleSort_Czas:88.566523 s 
 QuickSort_Czas:    0.023499 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   18.191195 s 
 BubbleSort_Czas:   86.920362 s 
 FlagBubbleSort_Czas:77.149972 s 
 QuickSort_Czas:      0.011188 s 

 Tablica 210000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.001050 s 
 BubbleSort_Czas:   51.613574 s 
 FlagBubbleSort_Czas:0.000479 s 
 QuickSort_Czas:     0.007690 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   50.022264 s 
 BubbleSort_Czas:   126.578476 s 
 FlagBubbleSort_Czas:118.210583 s 
 QuickSort_Czas:    0.028011 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   21.744284 s 
 BubbleSort_Czas:   114.410154 s 
 FlagBubbleSort_Czas:102.609569 s 
 QuickSort_Czas:      0.011348 s 

 Tablica 240000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.001211 s 
 BubbleSort_Czas:   65.906799 s 
 FlagBubbleSort_Czas:0.000536 s 
 QuickSort_Czas:     0.009069 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   64.769088 s 
 BubbleSort_Czas:   162.635062 s 
 FlagBubbleSort_Czas:154.274139 s 
 QuickSort_Czas:    0.031441 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   26.360804 s 
 BubbleSort_Czas:   146.455839 s 
 FlagBubbleSort_Czas:133.858919 s 
 QuickSort_Czas:      0.014587 s 

 Tablica 270000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.001350 s 
 BubbleSort_Czas:   83.934962 s 
 FlagBubbleSort_Czas:0.000600 s 
 QuickSort_Czas:     0.010089 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   78.806820 s 
 BubbleSort_Czas:   199.665385 s 
 FlagBubbleSort_Czas:193.535785 s 
 QuickSort_Czas:    0.036101 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   32.387655 s 
 BubbleSort_Czas:   181.679329 s 
 FlagBubbleSort_Czas:172.633379 s 
 QuickSort_Czas:      0.017826 s 

 Tablica 300000 tysięcy 

Kolejne Liczby Całkowite 
 InsertSort_Czas:   0.002108 s 
 BubbleSort_Czas:   103.996084 s 
 FlagBubbleSort_Czas:0.000720 s 
 QuickSort_Czas:     0.011130 s 

 Liczby Pseudolosowe całkowite 
 InsertSort_Czas:   74.915411 s 
 BubbleSort_Czas:   242.885486 s 
 FlagBubbleSort_Czas:245.421963 s 
 QuickSort_Czas:    0.040679 s 

 Liczby pseudolosowe całkowite z przedzialu od 0 do 2 
 InsertSort_Czas:   39.842656 s 
 BubbleSort_Czas:   222.693211 s 
 FlagBubbleSort_Czas:213.817479 s 
 QuickSort_Czas:      0.022640 s 

0

O Panie :D. Ile trwało ? Ja po godzinie odpuściłem.

0

A jak to wygląda od strony hardware.W sensie tu już prędkość wykonania tego programu zależy od taktowania procesora ?
Więc aby kod był uniwersalny i można było go porównywać na różnym sprzęcie to powinien być napisany tak aby każda iteracja była do przerobienia przez procesor w pojedynczym cyklu zakładając że standard to powiedzmy 2ghz. Czy dobrze wgl to rozumiem ?

0

Dobra. Dziękuję za pomoc Pzdr :)

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