please critique this code

The original question has been replaced by this updated code.  I think this is ok now.  If you see any glaring weaknesses other than O(n*n) time to sort please submit your response.

#include <stdio.h>

#define MAXNUM 10
#ifndef NULL
      #define NULL (double)(0)
#endif

struct opts {
      int is_alpha;
      int is_reverse ;
};

void get_opts(int argc, char *argv[], struct opts *s_opts);
void sort(double *input[], int n, struct opts *s_opts);
void swap(double **j, double **k);
void print_numbers(double *input[], int n);
int alpha(double j, double i);
int reverse(double i, double j);
void clear_kb(void);
void free_memory(double *input[], int n);

int main(int argc, char *argv[])
{
      double *input[MAXNUM];
      int n = 0;
      struct opts s_opts;
      double buffer;

      get_opts(argc, argv, &s_opts);

      printf("Sort method = %s\n\n", ((s_opts.is_alpha == 1) ? "alpha" : "reverse"));

      while (n < MAXNUM)
      {
            printf("Enter a number>");

            scanf("%lf", &buffer);
            clear_kb();

            if (buffer != NULL)
            {
                  if ((input[n] = (double *)malloc(sizeof(buffer))) != NULL)
                  {
                        *input[n++] = buffer;
                  }
                  else
                  {
                        puts("Memory allocation error.");
                        exit(1);
                  }
                  buffer = NULL;
            }
            else
                  puts("That is not a number.");
      }

      sort(input, n, &s_opts);
      print_numbers(input, n);
      free_memory(input, n);

      return 0;
}

void get_opts(int argc, char *argv[], struct opts *s_opts)
{
      int i = 1;

      if (argc > 1) {
            /* for each argv entry */

            for (i; i < argc; i++)
            {
                  /* if it is an option */
                  if (argv[i][0] == '-')
                  {
                        switch (argv[i][1])
                        {
                              case 'a':
                              {
                                    s_opts->is_alpha = 1;
                                    s_opts->is_reverse = 0;
                                    break;
                              }
                              case 'z':
                              {
                                    s_opts->is_alpha = 0;
                                    s_opts->is_reverse = 1;
                                    break;
                              }
                              default:
                              {
                                    s_opts->is_alpha = 1;
                                    s_opts->is_reverse = 0;
                              }
                        }
                  }
            }
      }
      else
      {
            s_opts->is_alpha = 1;
            s_opts->is_reverse = 0;
      }
}

void sort(double *input[], int n, struct opts *s_opts)
{
      int i, j;
      int (*pre_sorted)(double a, double b);

      pre_sorted = (s_opts->is_alpha == 1) ? alpha : reverse;

      for (i = 1; i <= n; i++)
      {
            for (j = 0; j < n-1; j++)
            {
                  if (!pre_sorted(*input[j], *input[j+1]))
                        swap(&input[j], &input[j+1]);
            }
      }
}

int alpha(double a, double b)
{
      return(a < b);
}

int reverse(double a, double b)
{
      return(a > b);
}

void swap(double **j, double **k)
{
      double *temp;

      temp = *j;
      *j = *k;
      *k = temp;
}

void print_numbers(double *input[], int n)
{
      int i;
      for (i=0; i<n; i++)
      {
            printf("%lf\n", *input[i]);
      }
}

void clear_kb(void)
{
      char junk[256];
      fgets(junk, 256, stdin);
}

void free_memory(double *input[], int n)
{
      int i;
      for (i = 0; i < n; i++)
            free(input[i]);
}