c语言实现顺序结构的线性表，可自动增加长度的

最近闲来无事，就顺便把数据结构再复习一下，在此把我刚写的c语言实现的顺序结构线性表送给大家，不要吝啬评论哦。

#include "stdio.h"


#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"


#define TRUE 1
#define FALSE 0


#define  MAXSIZE     100   // 线性表存储空间的初始分配量,
#define  INCREMENT    10     // 线性表存储空间的分配增量


//编码风格，所有变量单词第一个大写，函数的参数全部消协


typedef int ElemType;
typedef int Status;


//定义遍历函数
Status visit(ElemType &e)
{
    printf("%d\n",e);
    return TRUE;
}


typedef struct
{
    ElemType *Data;
    int Length;
    int Size;
}ArrayList;


/* 初始化顺序线性表 */
Status InitList(ArrayList *arraylist)
{
    arraylist->Data = (int *)malloc(MAXSIZE*(sizeof(ElemType)));
    arraylist->Length = 0;
    arraylist->Size = MAXSIZE;
    return TRUE;
}


/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(ArrayList *arraylist)
{
    if(arraylist->Length = 0)
        return TRUE;
    return FALSE;
}


/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ListClear(ArrayList *arraylist)
{
    arraylist->Length = 0;
    return TRUE;
}


/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(ArrayList *arraylist)
{
    return arraylist->Length;
}


/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(ArrayList *arraylist,int pos,ElemType *e)
{
    if(pos<1 || pos >arraylist->Length)
        return FALSE;
    *e = arraylist->Data[pos-1];
    return TRUE;
}


/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(ArrayList *arraylist,ElemType e)
{
    if(ListEmpty(arraylist))
        return FALSE;
    int  i;
    for(i=0;i<arraylist->Length;i++)
    {
        if(arraylist->Data[i] == e)
            return i+1;
    }
    return FALSE;
}


/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(ArrayList *arraylist,int pos,ElemType e)
{
    if(pos<1 || pos >arraylist->Length+1)
        return FALSE;
    if(arraylist->Length==arraylist->Size)
    {
        arraylist->Data = (int *)realloc(arraylist->Data,(MAXSIZE+INCREMENT)*sizeof(ElemType));
        if(arraylist->Data == NULL)
            exit(OVERFLOW);
        arraylist->Size += INCREMENT;
    }
    int i,j;
    for(i=pos-1,j=arraylist->Length-1;i<=j;i++)
        arraylist->Data[i+1] = arraylist->Data[i];
    arraylist->Data[pos-1] = e;
    arraylist->Length++;
    return TRUE;
}


/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(ArrayList *arraylist,int pos,ElemType *e)
{
    if(pos < 1 || pos >arraylist->Length)
        return FALSE;
    *e = arraylist->Data[pos-1];
    int i,j;
    for(i=pos-1,j=arraylist->Length-1;i<j;i++)
    {
        arraylist->Data[i] = arraylist->Data[i+1];
    }
    arraylist->Length-=1;
    return TRUE;
}


/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(ArrayList *arraylist)
{
    int i;
    for(i=0;i<arraylist->Length;i++)
        visit(arraylist->Data[i]);
    return TRUE;
}


/*初始条件：两个顺序结构实现的线性表*/
/*操作结果：将两个线性表求并放在另一个线性表中*/
Status unionArrayList(ArrayList *arraylist1,ArrayList *arraylist2,ArrayList *arraylist3)
{
    int i,elem;
    //求1和2并，放入3中
    //先把1种的元素放入3
    for(i=0;i<arraylist1->Length;i++)
    {
        if(!LocateElem(arraylist3,arraylist1->Data[i]))
        {
            ListInsert(arraylist3,arraylist3->Length+1,arraylist1->Data[i]);
        }
    }


    //再把2种的元素放入3
    for(i=0;i<arraylist2->Length;i++)
    {
        if(!LocateElem(arraylist3,arraylist2->Data[i]))
        {
            ListInsert(arraylist3,arraylist3->Length+1,arraylist2->Data[i]);
        }
    }
    return TRUE;
}


/*初始条件：两个顺序结构实现的线性表*/
/*操作结果：求两个集合的交集*/
Status jiaoArrayList(ArrayList *arraylist1,ArrayList *arraylist2,ArrayList *arraylist3)
{
    int i;
    for(i=0;i<arraylist1->Length;i++)
    {
        if(LocateElem(arraylist2,arraylist1->Data[i]))
        {
            ListInsert(arraylist3,arraylist3->Length+1,arraylist1->Data[i]);
        }
    }
    return TRUE;
}


/*初始条件：两个顺序结构实现的线性表*/
/*操作结果：把这个集合arraylist1中相同的元素去掉放在2中*/
Status uniqueArrayList(ArrayList *arraylist1,ArrayList *arraylist2)
{
    int i;
    for(i=0;i<arraylist1->Length;i++)
    {
        if(!LocateElem(arraylist2,arraylist1->Data[i]))
        {
            ListInsert(arraylist2,arraylist2->Length+1,arraylist1->Data[i]);
        }
    }
    return TRUE;
}


/*已经存在两个线性表，是非递减排列*/
/*要求进行归并排序,12放入3，要求仍然是非递减排列*/
Status mergeArrayList(ArrayList *arraylist1,ArrayList *arraylist2,ArrayList *arraylist3)
{
    InitList(arraylist3);
    int len_1 = arraylist1->Length;
    int len_2 = arraylist2->Length;
    int i=0,j=0;
    while(i<len_1&&j<len_2)
    {
        if(arraylist1->Data[i]>arraylist2->Data[j])
        {
            ListInsert(arraylist3,arraylist3->Length+1,arraylist2->Data[j]);
            j++;
        }
        else
        {
            ListInsert(arraylist3,arraylist3->Length+1,arraylist1->Data[j]);
            i++;
        }
    }
    while(i<len_1)
    {
        ListInsert(arraylist3,arraylist3->Length+1,arraylist1->Data[i]);
        i++;
    }
    while(j<len_2)
    {
        ListInsert(arraylist3,arraylist3->Length+1,arraylist1->Data[j]);
        j++;
    }
    return TRUE;
}
int main()
{
    int a = 1;
    ArrayList l1;
    InitList(&l1);
    ListInsert(&l1,1,a);
    ListInsert(&l1,1,a);
    ListTraverse(&l1);
    return 0;
}

有什么问题的话，欢迎提问哈