Heap Sort.

void heapsort( int a[], unsigned int n )
{
int i,temp;
for( i=n/2; i>=0; i-- )      /* build_heap */
shift_down (a, i, n-1 );
for( i=n; i>=1; i-- )
{
temp=a[0];
a[0]=a[i];
a[i]=temp;    /* delete_max */
shift_down( a, 0, i-1 );
}
}
void shift_down( int a[], unsigned int i, unsigned int n )
{
unsigned int child;
int tmp;
for( tmp=a[i]; i*2<=n; i=i*2 )
{
child = i;
if( ( child != n ) && ( a[child+1] > a[child] ) )
child++;
if( tmp < a[child] )
a[i] = a[child];
else
break;
}
a[i] = tmp;
}

Merge Sort.

mergesort( int a[], unsigned int n )
{
int *tmp_array;
tmp_array = (int*) malloc ( (n+1) * sizeof (int) );
if( tmp_array != NULL )
{
m_sort( a, tmp_array, 1, n );
free( tmp_array );
}
else
printf("No space for tmp array!!!");
}
void m_sort( int a[], int tmp_array[ ],int left, int right )
{
int center;
if( left < right )
{
center = (left + right) / 2;
m_sort( a, tmp_array, left, center );
m_sort( a, tmp_array, center+1, right );
merge( a, tmp_array, left, center+1, right );
}
}

void merge( int a[ ], int tmp_array[ ],int lpos,int rpos,int rend)
{
int i, lend, n, tmp_pos;
lend = rpos - 1;
tmp_pos = lpos
n = rend - lpos + 1;
/* main loop */
while( ( lpos <= lend ) && ( rpos <= rend ) )
if( a[lpos] <= a[rpos] )
tmp_array[tmp_pos++] = a[lpos++];
else
tmp_array[tmp_pos++] = a[rpos++];
while( lpos <= lend )  /* copy rest of first half */
tmp_array[tmp_pos++] = a[lpos++];
while( rpos <= rend ) /* copy rest of second half */
tmp_array[tmp_pos++] = a[rpos++];
/* copy tmp_array back */
for(i=1; i <= n; i++, rend-- )
a[rend] = tmp_array[rend];
}

Insertion Sort.

for ( i = 1 ; i <= 4 ; i++ )
 {
  for ( j = 0 ; j < i ; j++ )
  {
   if ( arr[j] > arr[i] )
   {
    temp = arr[j] ;
    arr[j] = arr[i] ;
    for ( k = i ; k > j ; k-- )
     arr[k] = arr[k - 1] ;
    arr[k + 1] = temp ;
   }
  }
 }

Quick Sort.

void quicksort ( int a[ ], int lower, int upper )
{
 int i ;
 if ( upper > lower )
 {
  i = split ( a, lower, upper ) ;
  quicksort ( a, lower, i - 1 ) ;
  quicksort ( a, i + 1, upper ) ;
 }
}

int split ( int a[ ], int lower, int upper )
{
 int i, p, q, t ;
 p = lower + 1 ;
 q = upper ;
 i = a[lower] ;
 while ( q >= p )
 {
  while ( a[p] < i )
   p++ ;
  while ( a[q] > i )
   q-- ;
  if ( q > p )
  {
   t = a[p] ;
   a[p] = a[q] ;
   a[q] = t ;
  }
 }
 t = a[lower] ;
 a[lower] = a[q] ;
 a[q] = t ;
 return q ;
}

Selection sort.

for ( i = 0 ; i <= 3 ; i++ )
 {
  for ( j = i + 1 ; j <= 4 ; j++ )
  {
   if ( arr[i] > arr[j] )
   {
    temp = arr[i] ;
    arr[i] = arr[j] ;
    arr[j] = temp ;
   }
  }
 }

Bubble Sort.

for ( i = 0 ; i <= 3 ; i++ )
 {
  for ( j = 0 ; j <= 3 - i ; j++ )
  {
   if ( arr[j] > arr[j + 1] )
   {
    temp = arr[j] ;
    arr[j] = arr[j + 1] ;
    arr[j + 1] = temp ;
   }
  }
 }