Untitled

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <math.h>
#include <process.h>

LARGE_INTEGER tick1, tick2, freq;

void Random(int Table[],int amount){
     int i;
     for(i = 0 ; i < amount ; ++i){
           Table[i] = rand()+rand()+rand()+rand()+rand();
           }

     }

void Swap(int Table[],int a,int b ){
     int temp;
     temp = Table[a];
     Table[a] = Table[b];
     Table[b] = temp;
     }

int BubbleSort(int Table[],int amount)
     {
                int i, j, x;

                for(i = 1 ; i < amount ; i++){
                      for(j = amount-1 ; j >= i ; j--){
                            if( Table[j-1] > Table[j] ){
                                Swap(Table,j-1,j);
                                }
                            }
                      }
     }

void Heapify(int Table[], int i, int Heapsize)
    {
     int Left = 2 * i + 1 , Right = 2 * (i + 1) , Largest;

     if((Left < Heapsize) && (Table[Left] > Table[i]))
             {Largest = Left;}
             else
             {Largest = i;}

     if((Right < Heapsize) && (Table[Right] > Table[Largest]))
              {Largest = Right;}

     if(Largest != i)
                {Swap(Table,i,Largest);
                Heapify(Table,Largest,Heapsize);}
    }

void BuildHeap(int Table[],int amount)
     {
      int i;
      int Heapsize = amount;
      for(i = ceil((amount+1)/2-1); i >= 0; i--)
            {
            Heapify(Table,i, Heapsize);
            }
     }

int HeapSort(int Table[],int amount)
    {
     int i,Heapsize=amount;

     BuildHeap(Table, amount);
     for(i = amount-1; i > 0 ; i--)
           {
                       Swap(Table,0,i);
                       Heapsize--;
                       Heapify(Table,0, Heapsize);
           }

    }

int CountingSort(int Table[], int amount)
    {

      int i, k=32768*5;
      int C[k], B[amount];
      for(i=0;i<k;i++){
                       C[i] = 0;}
      for(i=0;i<amount;i++){
                           C[Table[i]-1]++;
                           }
      for(i=1;i<k;i++){
                       C[i] += C[i-1];
                       }
      for(i=amount-1;i>=0;i--){
                                     B[C[Table[i]-1]-1] = Table[i];
                                     C[Table[i]-1]--;
                    }
    for(i=0;i<amount;i++){Table[i]=B[i];}
    }

int ShellSort(int Table[], int amount)
    {
    int i, j, k, x, m, t,l;
    double g = log10(amount);
    t= floor(g);
    int h[t];
    for(i=0;i<t;i++){h[i]=3*i+1;}
    for(m=0;m<t;m++){
                     k=h[m];
                     for(i=k;i<amount;i++){
                                         x=Table[i];
                                         j=i-k;
                                         while((x<Table[j])&&((j+k)<amount)){
                                                       Table[j+k] = Table[j];
                                                       j = j-k;
                                                                                                              }
                                         Table[j+k] = x;
                                         }
                     }
    }


int main(int argc, char *argv[])
{
    int amount, Table[150000], i,j;
    float Results[5][34];
     QueryPerformanceFrequency(&freq);
    srand( (unsigned)time( NULL ) );

    for(i=0;i<=20;i++){Results[0][i]=1000*i;}
    for(i=21;i<=33;i++){Results[0][i]=10000*(i-18);}

    for(i=0;i<=20;i++){
                       amount = i*1000;
                       int Table1[amount];
                       Random(Table,amount);
                       for(j=0;j<amount;j++){Table1[j]=Table[j];}

                       QueryPerformanceCounter( &tick1 );
                       BubbleSort(Table,amount);
                       QueryPerformanceCounter( &tick2 );
                       Results[1][i]=1000*( tick2.QuadPart - tick1.QuadPart ) / (float) (freq.QuadPart );

                       for(j=0;j<amount;j++){Table[j]=Table1[j];}
                       QueryPerformanceCounter( &tick1 );
                       HeapSort(Table,amount);
                       QueryPerformanceCounter( &tick2 );
                       Results[2][i]=1000* ( tick2.QuadPart - tick1.QuadPart ) / (float) (freq.QuadPart );

                       for(j=0;j<amount;j++){Table[j]=Table1[j];}
                       QueryPerformanceCounter( &tick1 );
                       CountingSort(Table,amount);
                       QueryPerformanceCounter( &tick2 );
                       Results[3][i]=1000* ( tick2.QuadPart - tick1.QuadPart ) / (float) (freq.QuadPart );

                       for(j=0;j<amount;j++){Table[j]=Table1[j];}
                       QueryPerformanceCounter( &tick1 );
                       ShellSort(Table,amount);
                       QueryPerformanceCounter( &tick2 );
                       Results[4][i]=1000* ( tick2.QuadPart - tick1.QuadPart ) / (float) (freq.QuadPart );
                       }

        for(i=3;i<=15;i++){
                       amount = i*10000;
                       Random(Table,amount);

                       QueryPerformanceCounter( &tick1 );
                       HeapSort(Table,amount);
                       QueryPerformanceCounter( &tick2 );
                       Results[2][i+18]=1000* ( tick2.QuadPart - tick1.QuadPart ) / (float) (freq.QuadPart );

                       Random(Table,amount);
                       QueryPerformanceCounter( &tick1 );
                       CountingSort(Table,amount);
                       QueryPerformanceCounter( &tick2 );
                       Results[3][i+18]=1000* ( tick2.QuadPart - tick1.QuadPart ) / (float) (freq.QuadPart );

                       Results[1][i+18]=0;
                       Results[4][i+18]=0;
                       }

    printf("\tBS\t\tHS\t\tCS\t\tShS\n");
    for(i=0;i<=33;i++){printf("%.0f\t%f\t%f\t%f\t%f\n",Results[0][i],Results[1][i],Results[2][i],Results[3][i],Results[4][i]);}
    system("pause");
  return 0;
}