我在编好了之后，用VS2008生成的时候发现有很多类型重定义和函数已有主体的错误。还请各位大虾指点。
程序代码如下：
#include <stdio.h>
#include<malloc.h>
#define MaxSize 100
typedef int DataType;
#include"LinkList.h"
#include "SListWithRearSize.h"

#include "OrdinalLink.h"

/**
 * main()运行带表尾和表长信息的单链表数据结构、有序单链表数据结构的测试实例。
 **/
void main(void)
{    
    
    SLNode *head;
    int i, x;
    ListInitiate(&head);     //初始化
    for(i = 0;i < 10;i ++)               //插入数据元素1~10
        ListInsert(head,i,i + 1);
    if(IsEmpty(head))
        printf("该链表为空链表！\n");
    else
        printf("该链表为非空链表！\n");
    for(i = 0;i < ListLength(head);i++)
    {
        ListGet(head, i, &x);
        printf("%d   ",x);
    }
    printf("\n");
    InsertFront(head,0);
    InsertEnd(head,11);
    for(i = 0;i < ListLength(head);i++)
    {
        ListGet(head, i, &x);
        printf("%d   ",x);
    }
    printf("\n");
    Find(head,11);
    FindPrevious(head,11);
    

}
==============================================================
/* LinkList.h*/
/**
 * LinkList实现单链表（带头结点）数据结构
**/

typedef struct Node
{
    DataType data;
    struct Node *next; //递归定义
}SLNode; /*单链表结点结构体类型SLNode*/

void ListInitiate(SLNode ** head)
//初始化单链表
{
    *head=(SLNode*)malloc(sizeof(SLNode));
    (*head)->next=NULL;
}

int ListLength(SLNode *head)
{//求以head为头指针的带头结点的单链表表长
 SLNode *p=head;
 int size=0;
 while(p->next!=NULL)
 {
     p=p->next;
     size++;
 }
 return size;
}

int ListGet(SLNode *head,int i,DataType *x)
/* 在以head为头指针的带头结点的单链表中，读取第i个元素,，由第三个参数返回 */
 {
     SLNode *p;
     int j;
     p=head;
     j=-1;  /*从头指针开始查找ai */
     while (p->next!=NULL && j<i)
     {
         p=p->next;
         j++;
     }//向后遍历
     if (j!=i    )
     {
         printf("读取位置i不合理! \n");
         return 0;
     }
     *x=p->data;
     return 1; 
}

int ListInsert(SLNode *head,int i,DataType x) 
/*在以head为头指针的带头结点的单链表中的第i个结点之前插入值为x的结点*/
{
    SLNode *p,*q; /*p：搜索指针，q：新生成指针*/
    int j;
    p=head;
    j= - 1;
    while (p->next!=NULL&&j<i-1)/*寻找第i-1个结点*/
    {
        p=p->next;
        j++;
    }
    if (j!=i-1)
    {
        printf("\n插入位置i不合理!");
        return 0;
    }
    /*产生新结点q*/
    q=(SLNode *)malloc (sizeof(SLNode));
    q->data=x;
    /*插入*/
    q->next=p->next;
    p->next=q;/*注意：上面两条语句的次序不能颠倒*/
    return 1;
}

int ListDelete(SLNode *head,int i,DataType *x)
///*删除以head为头指针的带头结点的单链表的第i个结点，由第三个参数返回其数据域*/
{
    SLNode *p,*s;
    int j;
    p=head;
    j= - 1;
    /*寻找第i-1个结点*/
    while (p->next!=NULL && p->next->next!=NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if (j!=i-1)
    {
        printf("\n删除位置不合理!");
        return 0;
    }
    /*删除*/
    s=p->next;
    *x=s->data;
    p->next=p->next->next;
    free(s);
    return 1;
}

void Destroy(SLNode **head)
//释放以head为头指针的带头结点的单链表所占的空间
{
    SLNode *p, *p1;
    p = *head;
    while(p != NULL)
    {
        p1 = p;
        p = p->next;
        free(p1);
    }
    *head = NULL;
}


/**
 *  isEmpty() 函数判断链表是否是空表，如果是空表则返回1，否则返回0
 **/
int IsEmpty(SLNode *head)
{
    
    SLNode *p = head;
    if(p->next == NULL)
        return 1;
    else
        return 0;    
}

/**
  *  insertFront() 函数在链表的第一个元素前插入一个新元素x，成功返回1，失败返回0。
 **/
int InsertFront(SLNode *head,int x) 
{
    
    SLNode *p, *q;
    p = head;
    if(IsEmpty(head))
    {
        printf("该链表是空链表，不存在第一个元素，无法插入！");
        return 0;
    }
    else
    {
        q = (SLNode *)malloc(sizeof(SLNode));
        q->data = x;
        q->next = p->next;
        p->next = q;
        return 1;
    }
}
/**
  *  insertEnd() 函数在链表的末尾结点后插入一个新元素x，成功返回1，失败返回0。
 **/
int InsertEnd(SLNode *head,int x)
{
    
    SLNode *p, *q;
    p = head;
    if(IsEmpty(head))
    {
        printf("该链表为空，不存在末尾结点，插入失败！");
        return 0;
    }
    while(p->next != NULL)
        p = p->next;
    q = (SLNode *)malloc(sizeof(SLNode));
    q->data = x;
    q->next = NULL;
    p->next = q;
    return 1;
}

/**
  *  Find() 函数在单链表中寻找值为x的元素，查找成功返回单链表中第一个值为x结点的地址，失败返回NULL。
 **/
SLNode * Find(SLNode *head,int x)
{
    //在此添加你的第一步4代码
    SLNode *p;
    int j = 0;
    p = head;
    if(IsEmpty(head))
        return NULL;
    while(j < ListLength(head))
    {
        p = p->next;
        j ++;
        if(p->data == x)
        {
            printf("链表中存在数据x！x结点的地址为：%x\n",&p);
            return p;
        }
    }
    printf("链表中不存在x！\n");
    return NULL;
}

/**
  *  FindPrevious函数在单链表中寻找值为x的元素，查找成功返回x结点的前一个结点的地址，失败返回NULL。
 **/
SLNode * FindPrevious(SLNode *head,int x)
{
    
    SLNode *p;
    int j = 0, i = 0;
    p = head;
    if(IsEmpty(head))
        return NULL;
    while(j < ListLength(head) && p->data != x)
    {
        p = p->next;
        j ++;
        
    }
    if(j == ListLength(head))
    {
        if(p->data != x)
            return NULL;
        else
        {
            p = head;
            i = -1;
            while(i < j - 2)
            {
                p = p->next;
                i ++;
            }
            printf("%d,%x\n",p->data,&p->next);
        }
    }
    else 
    {
        if(p->data != x)
            return NULL;
        else
        {
            p = head;
            i = -1;
            while(i < j - 2)
            {
                p = p->next;
                i ++;
            }
            printf("%d,%x\n",p->data,&p->next);
        }
    }
    
}
=====================================================
/* SListWithRearSize.h*/
/**
 * SListWithRearSize实现带尾指针和表长信息的单链表（带头结点）数据结构
**/
#include "LinkList.h"

typedef struct
{
    struct Node * head;         //头指针
    //在此增加你定义的新的数据成员（第三步）
   struct Node *rear;           //尾指针
    //在此增加你定义的新的数据成员（第三步）
   int size;
}SListWithRearSize; /*带尾指针和表长信息的单链表类型定义*/

void SListInitiate(SListWithRearSize *L)
//初始化带尾指针和表长信息的单链表
{
    
    ListInitiate(&(L->head));
    L->head->next = L->head;   //循环结构
    L->rear = L->head;       //尾指针处理
    L->size = 0;             //链表长度初始化为0
}

int SListLength(SListWithRearSize L)
//求带尾指针和表长信息的单链表的表长
{
    return L.size;

}

int SListInsert(SListWithRearSize *L,int i,DataType x) 
/*在带尾指针和表长信息的单链表中的第i个结点之前插入值为x的结点*/
{
    SLNode *p, *q;
    int j;
    p = L->head;
    j = -1;
    while(p->next != NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if(j != i - 1)
    {
        printf("");
        return 0;
    }
    q = (SLNode *)malloc(sizeof(SLNode));
    q->data = x;
    if(i != L->size)
    {
        q->next = p->next;
        p->next = q;
        L->size++;
        return 1;
    }
    else
    {
       q->next = L->rear->next;
       L->rear->next = q;
       L->rear = q;
       L->size ++;
       return 1;
    }

}

int SListDelete(SListWithRearSize *L,int i,DataType *x)
//在带尾指针和表长信息的单链表删除第i个结点，数据域由第三个参数返回
{
    SLNode *p, *s;
    int j;
    p = L->head;
    j = -1;
    while(p->next != NULL && p->next != NULL && j < i - 1)
    {
        p = p->next;
        j ++;
    }
    if(j != i - 1)
    {
        printf("删除位置参数错误！");
        return 0;
    }
    if(i = L->size -1)
    {
        s = p->next;
        *x = s->data;
        p->next = L->rear->next;
        L->rear = p;
        free(s);
    }
    else
    {
        s = p->next;
        *x = s->data;
        p->next = p->next->next;
        free(s);
    }
    return 1;
}

void SListDestroy(SListWithRearSize *L)
////释放带尾指针和表长信息的单链表所占的空间
{
    Destroy(&(L->head));
}

/**
  *  SListInsertFront() 函数在带尾指针和表长信息的单链表的第一个元素前插入一个新元素x，成功返回1，失败返回0。
 **/
int SListInsertFront(SListWithRearSize *L,int x) 
{

    SLNode *q;
    if(L->head->next == L->head)
        return 0;
    q = (SLNode *)malloc(sizeof(SLNode));
    q->data = x;
    q->next = L->head->next;
    L->head->next = q;
    L->size ++;
    return 1;
}
/**
  *  SListInsertEnd() 函数在带尾指针和表长信息的单链表的末尾结点后插入一个新元素x，成功返回1，失败返回0。
 **/
int SListInsertEnd(SListWithRearSize *L,int x)
{

    SLNode *q;
    if(L->head->next == L->head)
        return 0;
    q = (SLNode *)malloc(sizeof(SLNode));       //新结点
    q->data = x;
    q->next = L->rear->next;
    L->rear->next = q;
    L->rear = q;
    L->size ++;
    return 1;
}
==============================================
/*OrdinalLink.h*/
/**
 * OrdinalLink实现有序单链表数据结构
**/

#include "LinkList.h"


/**
 * OrdinalListInsert()在单链表中合适位置插入元素x，使得链表中的数据元素按值非递减有序排列。
 **/
int OrdinalListInsert(SLNode *head,DataType x)
{ 
    
    return 0;
}

/**
 * OrdinalListDelete()在有序单链表中删除值为x的元素。
 **/
int OrdinalListDelete(SLNode *head,DataType x)
{ 
    
    return 0;
}

/**
 * OrdinalListMerge()将非递减有序单链表La、Lb合并为有序单链表Lc，并且单链表Lc也按值非递减有序。
 **/

int OrdinalListMerge(SLNode *head1,SLNode *head2,SLNode **head3)
{    

    return 0;
}
=======================================================
当然，代码还没编完。面对如此多的错误我实在是没有了编下去的勇气了。