线性表的顺序存储结构（一）

不管三七二十一先贴代码
申明一下代码是参照李春葆《数据结构教程》修改

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

//C语言没有boolean
typedef int bool;  //这里的分号不要忘记了，宏定义不需要加分号
#define true  1    
#define false 0

//利用宏来模拟参数默认值
//C语言既不支持重载也不支持默认参数
#define DEFARG(name, defval) ((#name[0]) ? (name + 0 ) : defval)
#define DeleteElem1(lsit, index, arg0) DeleteElem(lsit, index, DEFARG(arg0, NULL))

#define MAXSIZE 50

typedef int ElemType;
typedef struct
{
    ElemType Elem[MAXSIZE];
    int Size;     //容量
}List;

//约定：index为物理位置序号
bool CreateList(List* &L, ElemType arr[], int index)
{
    int i = 0;

    if (index < 1 || index > MAXSIZE) {
        printf("Index Outsize\n");
        return false;
    }

    (*L) = (List*)malloc(sizeof(List));
    if (*L == NULL) {
        printf("malloc failed!\n");
        return false;
    }

    /*
    在这里还犯一个错误，书上bool CreateList(List* &L, ElemType arr[], int index)用C编译不过，然后我就改了，
    bool CreateList(List* L, ElemType arr[], int index)
我去掉了引用&，是这样想的，malloc一个新的地址，然后改变这个新地址的内容，然后把这个新地址赋值给L，就OK了，
想的很简单，然后就杯具了，实参对象的内容没有任何变化，开始还一直想不明白，直到问了大牛。
我是传了一个形参指针，一般形参指针只能改变它所指向内存地址里的内容，但是现在我们malloc了一个
新地址，并且对这个新地址做了初始化，我们真正要做的是改变指针的指向，使实参对象指向一个新的地址。
一级指针只能改变它所指向的变量的值，要想改变一级指针指向需要传一个二级指针或者一级指针的引用，
通过它改变一级指针的值。

    for (; i < index; ++i) {
        (*L)->Elem[i] = arr[i];
    }
    (*L)->Size = index;

    return true;
}

void DispList(List *L)
{
    int i = 0;
    for (; i < L->Size; i++) {
        printf("%d ", L->Elem[i]);
    }
    printf("\n");
}

bool IsEmpty(List *L)
{
    return ((L->Size == 0) ? true : false);
}

int GetSize(List* L)
{
    return L->Size;
}

//约定：index为物理位置
bool GetElem(List* L, int index, ElemType* e)
{
    //List本身不能为空，且查找不能越界
    if (L->Size == 0 || index < 1 || index > L->Size) {
        *e = -999999;
        return false;
    }

    index--;  //转换为逻辑序号
    *e = L->Elem[index];

    return true;
}

//返回线性表中所找到的第一个元素e的物理位置序号
bool LocatElem(List* L, int* index, ElemType e)
{
    int i = 0;
    for (; i < L->Size; ++i) {
        if (L->Elem[i] == e) {
            *index = (++i);
            return true;
        }
    }

    *index = -999999;
    return false;
}

//约定：InsetList是将元素插入到index位置
//e插入元素
bool InsertList(List* L, int index, ElemType e)
{
    //插入的线性表不能满，且插入位置最小为1，最大为L->Size+1.
    if (L->Size == MAXSIZE || index < 1 || index > L->Size + 1) {
        return false;
    }

#if 0
    int i = L->Size;//这里不用转换成逻辑序号，因为我们要往后移一位
    index--;        //转换为逻辑序号
    for (; i > index; --i)
        L->Elem[i] = L->Elem[i - 1];
    /*执行顺序是：初始化--判断--函数体——然后for循环的第3句--判断——函数体---for循环的第三句--判断……
    最后一次循环操作是i = index + 1, 将index处的内容赋值给index + 1处，然后执行for循环第三句：减一，判断不满足条件循环结束*/
#endif

#if 1
    //若插入数据不在标尾
    int j;
    index--;   //转换为逻辑序号
    if (index < L->Size) {
        for (j = L->Size - 1; j >= index; --j)
            L->Elem[j + 1] = L->Elem[j];
    }

#endif

    L->Elem[index] = e;
    L->Size++;

    return true;
}

//约定：删除index(物理序号)处的元素，由e返回
bool DeleteElem(List* L, int index, ElemType* e)
{
    if (L->Size == 0 || index < 1 || index > L->Size) {
        return false;
    }

    int i = index - 1;
    for (; i < L->Size; ++i)
        L->Elem[i] = L->Elem[i + 1];
    L->Size--;

    return true;
}


int main()
{
    ElemType arr[] = { 1, 2, 3, 4, 5, 6, 7 };
    List *lsit;

    CreateList(&lsit, arr, 7);
    DispList(lsit);

    printf("GetSize():%d\n", GetSize(lsit));

    printf("Insert:\n");
    InsertList(lsit, 2, 10);
    DispList(lsit);
    InsertList(lsit, 1, 22);
    DispList(lsit);
    InsertList(lsit, 7, 278);
    DispList(lsit);
    InsertList(lsit, 10, 92);
    DispList(lsit);

    printf("\nDelete:\n");
    DeleteElem1(lsit, 1,);
    DispList(lsit);
    DeleteElem1(lsit, 3, );
    DispList(lsit);
    DeleteElem1(lsit, 2, );
    DispList(lsit);

    printf("IsEmpty():%d\n", IsEmpty(lsit));

    printf("\nGetElem:\n");
    ElemType e;
    GetElem(lsit, 3, &e);
    printf("GetElem(3):%d\n", e);

    ElemType e1;
    GetElem(lsit, 7, &e1);
    printf("GetElem(7):%d\n", e1);

    ElemType e2;
    GetElem(lsit, 21, &e2);
    printf("GetElem(21):%d\n", e2);

    printf("\nLocatElem:\n");
    int index1;
    LocatElem(lsit, &index1, 1);
    printf("LocatElem(1):%d\n", index1);

    int index2;
    LocatElem(lsit, &index2, 3);
    printf("LocatElem(3):%d\n", index2);

    int index3;
    LocatElem(lsit, &index3, 92);
    printf("LocatElem(92):%d\n", index3);

    int index4;
    LocatElem(lsit, &index4, 31);
    printf("LocatElem(31):%d\n", index4);

    return 0;
}

注：本人正在学习状态，文中多有引用，也有解释纰漏之处，敬请包涵、指正！