Linked List (insertion sort)

[ATXFG]

Here is the list of instructions on this assignment I am currently working on:

Implement a Base 7 or Base 21 InsertionSort algorithm

• Input: File containing a list of Base 21 numbers
  • Name of this file is supplied on the command line
  • First element in file is number of entries
  • You may assume all numbers have at most 4 digits
• Output File containing a sorted list of Base 21 numbers and the decimal equivalent
  • Name of this file is supplied on the command line
  • First element in file is number of entries
• Implementation requirements
  • Validate input
    • Make sure input file exists & can be opened; make sure output file can be opened
    • Validate the date from the input file. That is, be sure each value really is appropriate for base 21.
  • Compare function named CompareB7 or CompareB21
    • Prototype: int CompareB721( Number1, Number 2)
    • Return value:
      • -1: Number1 < Number2
      • 0: Number1 == Number2
      • 1: Number1 > Number2
    • Number1 & Number2 data types
      • Base7: I recommend int
      • Base21: I recommend char *
    • Usage: use this file for all comparisons that form the basis of the logic in the InsertionSort algorithm
• Implement InsertionSort function
• In your submission, be sure to display the input/output file contents

here is the code I have so far, I have just having trouble with the instructions listed above. I am not sure how to write the insertion sort and Base 21 part of this program. Any help would be greatly apperciated. Thanks for your time.

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

/* --------------------------------------------------------------------- */

struct NumNodeType
{
    int dat;
    struct NumNodeType *next;
};

/* Define new type names:  BaseElem   and   BasePtr   
 * to refer to the list nodes.  These new names can
 * be used in place of struct NumNodeType and
 * struct NumNodeType *  repsectively.
 */
typedef struct NumNodeType BaseElem;
typedef struct NumNodeType * BasePtr;


/* --------------------------------------------------------------------- */

BasePtr GetNode( int val )
{
    BasePtr node;
    node = malloc( sizeof(BaseElem) );
    node->dat = val;
    node->next = NULL;
    return node;    
}


int Length( BasePtr first )
{
    BasePtr move;
    int len=0;
    move = first;
    while (move != NULL)
    {
        len++;
        move = move->next;
    }
    return len;
}


void PrintNode( BasePtr node )
{
    printf("Val: %d\n", node->dat);
}

void PrintList( BasePtr first )
{
    BasePtr move;
    move = first;
    while (move != NULL)
    {
        PrintNode( move );
        move = move->next;
    }
}

void PrintNodeFile( FILE *ofp, BasePtr node )
{
    fprintf(ofp, "Val: %d\n", node->dat);
}

void PrintListFile( FILE *ofp, BasePtr first )
{
    BasePtr move;
    move = first;
    while (move != NULL)
    {
        PrintNodeFile( ofp,  move );
        move = move->next;
    }
}

int Compare( int x, int y)
{
    if (x < y) return -1;
    else if (x == y) return 0;
    else if (x > y) return 1;
}

BasePtr FindInsLoc( BasePtr first, BasePtr node )
{
    BasePtr move, prev;
    int val1, val2;
    int res = -1;
    val2 = node->dat;
    move = first;
    prev = move;

    val1 = move->dat;
    res = Compare( val1, val2 );

    while ( res < 0 && move != NULL)
    {
        prev = move;
        move = move->next;
        if (move != NULL)
        {
            val1 = move->dat;
            res = Compare( val1, val2 );
        }
    }    
    return prev;
}

BasePtr InsertNodeAfter( BasePtr first, BasePtr loc, BasePtr node)
{
    //printf("Insert %d after %d\n", node->dat, loc->dat);
    node->next = loc->next;
    loc->next = node;
    return first;
}


/* --------------------------------------------------------------------- */

int main( int argc, char *argv[] )
{
    BasePtr head, tail, tmp;
    int i;

    FILE *infile, *outfile;
    /* verify that 2 parameters were passed */    
    if ( argc != 3)
    {
        printf("Usage: a.out infile outfile\n");
        return 1;
    }
    /* open input file */
    infile = fopen( argv[1], "r");
    if (!infile)
    {
        printf("ERROR: file %s not available\n", argv[1]);
        return 1;    
    }
    /* open output file */
    outfile = fopen( argv[2], "w");
    if (!outfile)
    {
        printf("ERROR: file %s not available\n", argv[2]);
        return 1;    
    }

    tmp = GetNode(1);
    head=tmp;
    tail=tmp;

    for (i = 2; i <= 7; ++i)
    {
        tmp = GetNode(i);
        tail->next = tmp;
        tail = tmp;
    }

    PrintList( head );

    fprintf(outfile, "Starting --\n");
    PrintListFile(outfile, head );
    fprintf(outfile, "Stopping --\n");
    i = Length( head );
    printf("List size: %d\n", i); 


    /* now make it work some some random data; the above
     * code is a test case in a controlled situation to make
     * sure things appear to work
     */
  /* insertion sort */
    srand( time(0) );

    BasePtr start, p, add;
    int x;
    tmp = GetNode(0);
    start=tmp;

    for (i = 1; i < 10; ++i)
    {
        x = rand() % 100 + 1;
        //printf("Inserting %d\n", x);
        add = GetNode(x);
        p = FindInsLoc( start, add );
        start = InsertNodeAfter( start, p, add );
        //printf("Version %d: \n", i);
        //PrintList( start );
    }

    printf("Sorted list ----- \n");
    PrintList( start );

    return 0;
}