quicksort/mergesort implementation in C

sort.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ELEMENTS 100

void quicksort(int array[], int left, int right);
void mergesort(int array[], int length);

void printarray(int array[], int length)
{
  int i;
  printf("Array: ");
  for(i = 0; i<length; i++)
    printf("%d, ", array[i]);
  printf("\n");
}

int main(int argc, char *argv[])
{
  // Inserting data...
  int i;
  int number;
  int array[ELEMENTS];

  if (argc < 2)
  {
    printf("Usage: %s <quicksort|mergesort>\n", argv[0]);
    return 1;
  }

  if (strcmp(argv[1], "quicksort") && strcmp(argv[1], "mergesort"))
  {
    printf("Usage: %s <quicksort|mergesort>\n", argv[0]);
    return 2;
  }

  for (i = 0; i<ELEMENTS; i++)
  {
    int number = rand() / (RAND_MAX / 1000);
    array[i] = number;
  }

  printf("Before sorting...\n");
  printarray(array, ELEMENTS);
  printf("\n");
  if (strcmp(argv[1], "quicksort"))
  {
    printf("Doing quicksort...\n");
    quicksort(array, 0, ELEMENTS - 1);
  }
  if (strcmp(argv[1], "mergesort"))
  {
    printf("Doing mergesort...\n");
    mergesort(array, ELEMENTS);
  }
  printf("After sorting...\n");
  printarray(array, ELEMENTS);

  return 0;
}

/*
 * Stack based merge sort..
 */
void mergesort(int array[], int length)
{
  int i, li, ri;
  int sizeleft = length / 2;
  int sizeright = length - sizeleft;
  int left[sizeleft];
  int right[sizeright];

  if(length == 1)
    return;

  // Split the array in two smaller...
  li = 0;
  ri = 0;
  for(i = 0;i<length;i++)
  {
    if(i<sizeleft)
    {
      left[li] = array[i];
      li++;
    }
    else
    {
      right[ri] = array[i];
      ri++;
    }
  }

  // Sort them..
  mergesort(left, sizeleft);
  mergesort(right, sizeright);

  // Copy data back in our main array...
  li = 0;
  ri = 0;
  for(i = 0;i<length;i++)
  {
    if((left[li] <= right[ri] && li < sizeleft) || ri == sizeright)
    {
      array[i] = left[li];
      li++;
    }
    else
    {
      array[i] = right[ri];
      ri++;
    }
  }

}

int partition(int array[], int left, int right, int pivot)
{
  int tmpval, pivotval, store, i;

  // Swap pivot out of the way...
  pivotval = array[pivot];
  array[pivot] = array[right];
  array[right] = pivotval;
  store = left;

  // Start sorting..
  for(i = left;i < right;i++)
  {
    if(array[i] <= pivotval)
    {
      tmpval = array[i];
      array[i] = array[store];
      array[store] = tmpval;
      store++;
    }
  } 

  // Move pivot into the last store place...
  array[right] = array[store];
  array[store] = pivotval;
  return store;
}

/*
 * In place quicksort algorithm..
 */
void quicksort(int array[], int left, int right)
{
  int pivot, newpivot;

  if(left < right)
  {
    // We choose the middle index...
    int pivot = left + (right - left)/2;
    //printf("Sorting partition from %d to %d (pivot %d)\n", left, right, pivot);
    newpivot = partition(array, left, right, pivot);
    quicksort(array, left, newpivot - 1);
    quicksort(array, newpivot + 1, right);
  }

  return;
}