Sortarile

public class tema {
static void inssort(int x[]){
      int j=0;
      int i=0;
      int n=x.length;
      for(j=0;j<n;j++){
        int k=x[j];
        i=j-1;
      while((i>=0)&&(x[i]>k)){x[i+1]=x[i];
                i=i-1;       }
              x[i+1]=k;     }
      }

static void selsort1(int x[]){    //selsort1
        int i=0;
        int j=0;
        int n=x.length;
    for(i=0;i<n-1;i++){
        int min=i;
       
      for(j=i+1;j<n;j++)
          if(x[j]<x[min])
              min=j;
        int a=x[i];
        x[i]=x[min];
        x[min]=a;
    }
}
/*static void selsort2(int x[]){
        int i=0;
        int j=0;
        int n=x.length;
    for(i=0;i<n-1;i++)
        for(j=i+1;j<n;j++){
            if(x[j]<x[i])
           
               
        }
   
}*/
static void bubblesort1(int x[]){
        int i=0;
        int j=0;
        int n=x.length;
   
    for( i=0;i<n;i++)
        for(j=0 ;j<n-1;j++)
                if(x[j]>x[j+1]){
                    int a=x[j];
                    x[j]=x[j+1];
                    x[j+1]=a;
                }
}
static void bubblesort2(int x[]){           
    int i=0;
    int j=0;
    int n=x.length;

for( i=0;i<n-1;i++)
    for(j=0 ;j<n-i;j++)
            if(x[j]>x[j+1]){
                int a=x[j];
                x[j]=x[j+1];
                x[j+1]=a;
            }
}

static void quicksort(int x[], int primul,int ultimul){
       
        int temp,min,max,mijl;
       
        mijl=x[primul+(ultimul-primul)/2];
        min=primul;max=ultimul;
       
        do
        {   
                while ( x[min]< mijl )
                    min++;
                while ( x[max]>mijl )
                    max--;
               
                if (min<=max){
                    temp=x[min];
                    x[min++]=x[max];
                    x[max--]=temp;
                                   
                }
               
        }     while(min<=max);   
               
              
                if (primul < max){
                    quicksort (x,primul,max);}
                if (ultimul > min){
                    quicksort (x,min,ultimul);}
           
}

static void mergesort(int x[],int st, int m , int dr){
       
        int b[]=new int[100000];
                       
                       
          int i,j,k;
       
        i=0;j=st;
       
        while(j<=m)
            b[i++]=x[j++];
       
        i=0;k=st;
       
        while((k<j)&& (j<=dr))
            if(b[i]<=x[j])
                x[k++]=b[i++];
            else
                x[k++]=x[j++];
   
        while(k<j)
            x[k++]=b[i++];
}
static void merge(int x[],int st,int dr){
    if(st<dr)
    {
        int m =(st+dr)/2;
        merge(x,st,m);
        merge(x,m+1,dr);
        mergesort(x,st,m,dr);
    }
}

public static void main(String [] args){
   
      int tab[] = new int[100000];
      for(int i=0;i<tab.length;i++)
        tab[i]=(int)Math.round(Math.random()*10000);
      long t1=System.currentTimeMillis();
               inssort(tab);                        // in jur de 6 secunde // 8 CPU'S
      long t2=System.currentTimeMillis();
          long d=t2-t1;
         
         
     //     for(int k=0;k<tab.length;k++)
    //      System.out.println(tab[k]);
         
          
              System.out.println(d);
             
/////////////////////////////////////////////////////////////             
             
      int tab1[]=new int[100000];
      for(int i=0;i<tab1.length;i++)
          tab1[i]=(int)Math.round(Math.random()*10000);
      long t3=System.currentTimeMillis();
          selsort1(tab1);                        // in jur de 14    secunde               
      long t4=System.currentTimeMillis();
         long e=t4-t3;  
              
        // for(int k=0;k<tab1.length;k++)
        //     System.out.println(tab1[k]);
         
              System.out.println(e);
             
////////////////////////////////////////////////////////////             
         
     int tab2[]=new int[100000];
     for(int i=0;i<tab2.length;i++)
         tab2[i]=(int)Math.round(Math.random()*10000);
     long t5=System.currentTimeMillis();
         bubblesort1(tab2);                        // in jur de  36 secunde
     long t6=System.currentTimeMillis();
         long f=t6-t5;
        
     //    for(int k=0;k<tab2.length;k++)
     //        System.out.println(tab2[k]);
        
         System.out.println(f);
        
////////////////////////////////////////////////////////////////             
     
     int tab3[]=new int[100000];
     for(int i=0;i<tab3.length;i++)
         tab3[i]=(int)Math.round(Math.random()*10000);
    
     long t7=System.currentTimeMillis();
    
     quicksort (tab3,0,99999);            // 14 milisecunde :)) asta e mai rapid ca Buggati :))
    
     long t8=System.currentTimeMillis();
         long g=t8-t7;
        
         //for(int k=0;k<tab3.length;k++)
         //    System.out.println(tab3[k]);
        
         System.out.println(g);

////////////////////////////////////////////////////////////////
        
         int tab4[]=new int[100000];
         for(int i=0;i<tab3.length;i++)
             tab4[i]=(int)Math.round(Math.random()*10000);
        
         long t9=System.currentTimeMillis();
        
             merge(tab4,0,99999);            // 7 secunde    
            
           long t10=System.currentTimeMillis();
             long h=t10-t9;
        
         //for(int k=0;k<tab4.length;k++)
         //    System.out.println(tab4[k]);
        
        System.out.println(h);
   
      }
}